l43_rmap 0.1.0

data/lib/l43_rmap/cli.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'l43/opt_parser'
+require 'l43/simple_color'
+require_relative '../l43_rmap'
+require_relative 'predefined_patterns'
+require_relative 'cli/color'
+require_relative 'cli/help'
+module L43Rmap
+  class Cli
+    include L43::SimpleColor
+    include Color
+    include Help
+
+    attr_reader :args, :kwds, :pattern, :runtime
+
+    def run(args)
+      parser.parse(args) => :ok, {kwds:, args:}
+      @kwds = kwds
+      @args = args
+      return help if kwds.help
+      return help_pattern if kwds.help_pattern
+      return help_named if kwds.help_named
+      return help_predefined if kwds.help_predefined
+      return help_sexp if kwds.help_sexp
+
+      return unless check_args
+
+      return dry_run if kwds.dry_run
+      replace_pattern_if_predefined
+      return show_parsed if kwds.parse_only
+
+      _compile
+      return compiled if kwds.compile_only
+
+      _run
+    end
+
+
+    private
+    def initialize
+      parser
+        .usage("rmap", options: true, args: 'pattern')
+      parser
+        .section("Flags")
+        .flag(:compile_only, :c, desc: ["Only compile ", :bold, :blue, "pattern"])
+        .flag(:parse_only, :p, desc: ["Only parse ", :bold, :blue, "pattern"])
+        .flag(:dry_run, :d, desc: "Only parse args")
+        .flag(:help_named, desc: ["Describe all ", :bold, :blue, "named fields"], stop: true)
+        .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)
+        .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)
+        .keyword(:pattern, desc: ["use a predefined pattern instead of positional argument. ",  :bold, "Conflicts with ", :blue, "pattern"], default: nil)
+      
+    end
+
+    def _compile 
+      @runtime = L43Rmap.compile(pattern)
+    end
+
+    def _run 
+      untime.run(kwds.input, kwds.output)
+      :ok
+    end
+
+    def check_args
+      args in [pattern]
+      @pattern = pattern
+      return check_pattern if pattern
+      return true if kwds.pattern
+      puterr("need exactly one positional arg as ", :blue, "pattern", :reset, nil, "but got: ", :yellow, :bold, args.inspect)
+      puthint
+    end
+
+    def check_pattern
+      return true unless kwds.pattern
+      puterr("must not have positonal arg as ", :blue, :bold, "pattern", :white, " and", kwd("pattern"))
+      puthint
+    end
+      
+    def compiled
+      putcol(:magenta, runtime.image)
+      :ok
+    end
+
+    def dry_run
+      putcol(:cyan, :bold, {kwds: kwds.to_h}.inspect)
+      putcol(:blue, :bold, {args:}.inspect)
+      :ok
+    end
+    def replace_pattern_if_predefined
+      return unless kwds.pattern
+      @pattern = PredefinedPatterns.get_pattern(kwds.pattern)
+    end
+
+    def show_parsed
+      ast = Parsing::ChunkParser.new.parse(pattern)
+
+      p ast.map(&:image)
+    end
+
+    def parser =  @__parser__ ||= L43::OptParser.new(with_help: true)
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/compiler.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'ast'
+require_relative 'evaluator'
+require_relative 'function'
+require_relative 'functions'
+module L43Rmap
+  class Compiler
+    Function = L43Rmap::Function
+    Functions = L43Rmap::Functions
+
+    def compile(ast) = ast.map { compile_chunk it }
+
+    private
+    def compile_chunk(chunk)
+      # p(compile_chunk: chunk.to_h)
+      case chunk
+      in Ast::Verb | Ast::Int
+        chunk
+      in {type: :named_field, value:}
+        compile_function(value)
+      in {type: :indexed_field, value:}
+        compile_field(value)
+      in {type: :sexp, value:}
+        compile_sexp(value)
+      in {type: :str, value:}
+        compile_str(value)
+      in {type: :sym, value:}
+        compile_sym(value)
+      end
+    end
+
+    def compile_field(value)
+      return compile_line if value.zero?
+      return compile_subfield value if value < 0
+      compile_subfield value.pred
+    end
+
+    def compile_function(name)
+      Functions.get_field(name)
+      # TODO: Fallbacks
+      # -> (rt, *a, **k) { rt.opstack.push(rt.opstack.pop.send(rt, *a, **k)) } 
+    end
+
+    def compile_line
+      Function.new("line") { |rt| rt.line }
+    end
+
+    def compile_sexp(value)
+      value => head, *tail
+      compiled_head = Functions.get_function(head.value)
+      compiled_args = compile_sexp_args(tail)
+      # p(compiled_args:)
+      Evaluator.new(compiled_head, compiled_args)
+    end
+    
+
+    def compile_sexp_args(tail) = tail.map { compile_chunk it }
+
+    def compile_str(value) = Function.new("str('#{value}')") { |*| value }
+
+    def compile_sym(value) = Function.new("sym('#{value}')") { |*| value.to_sym }
+
+    def compile_subfield(value) = Function.new("subfield #{value}") { |rt| rt.fields[value] }
+      
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/evaluator/evaluations.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../ast'
+require_relative  '../function'
+module L43Rmap
+  class Evaluator
+    module Evaluations extend self
+      def evaluate(chunk, rt:) = _eval(chunk, rt:)
+
+      private
+      def _eval(chunk, rt:)
+        # p(chunk:)
+        case chunk
+        in Function 
+          chunk.(rt)
+        else
+          chunk.value
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/evaluator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'evaluator/evaluations'
+module L43Rmap
+  class Evaluator
+
+    attr_reader :args, :fun
+
+    def call(rt)
+      #TODO: extract evaluate
+      real_args = args.map do |arg| arg.(rt) end
+
+      # p(real_args:)
+      fun.(rt, *real_args)
+    end
+
+    def image = "Evaluator #{fun.name}"
+
+    private
+    def initialize(fun, args)
+      @args = args
+      @fun = fun
+    end
+
+      
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/function.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module L43Rmap
+  class Function
+
+    attr_reader :name, :function
+
+    def call(rt, *a, **k) = function.(rt, *a, **k)
+
+    def image = "Function #{name}"
+
+    private
+    def initialize(name, &function)
+      @name = name
+      @function = function
+    end
+      
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module L43Rmap
+  module Functions
+    module Predefined
+      module Shell extend self
+        def se(rt, *args)
+          case args
+          in []
+            rt.line.shellescape
+          in [fn]
+            fn.shellescape
+          else
+            raise ArgumentError, "se needs at most 1 argument, but got: #{args.inspect}"
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/functions/predefined.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../evaluator/evaluations'
+require_relative 'predefined/shell'
+
+module L43Rmap
+  module Functions
+    module Predefined
+      extend L43Rmap::Evaluator::Evaluations
+      class << self
+        def if_fn(_rt, cond, true_branch, false_branch=nil)
+          if cond
+            true_branch
+          else
+            false_branch
+          end
+        end
+
+        def inc(_rt, *args)
+          case args
+          in []
+            raise ArgumentError, "inc needs at least 1 argument" if args.empty?
+          in [arg] 
+            arg.to_i.succ
+          else
+            args.map(&:to_i).sum
+          end
+        end
+
+        def file_extension(rt, *args)
+          case args
+          in []
+            File.extname(rt.line)[1..]
+          in [fn]
+            File.extname(fn.to_s)[1..]
+          else
+            raise ArgumentError, "ext needs at most 1 argument"
+          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)
+        end
+      end
+
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/functions.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative 'function'
+require_relative 'functions/predefined'
+
+module L43Rmap
+  module Functions
+
+
+    DefinedFields = {
+      # Linenumber
+      "n" => Function.new("lnb") { |rt| rt.lnb },
+
+      # Timestamps
+      "m" => Function.new("timestamp m") { |rt| rt.runtime.timestamp(36) },
+      "ms" => Function.new("timestamp ms") { |rt| rt.runtime.timestamp(36, mult: 1) },
+      "M" => Function.new("timestamp M") { |rt| rt.runtime.timestamp(36, now: rt.time) },
+      "Ms" => Function.new("timestamp Ms") { |rt| rt.runtime.timestamp(36, now: rt.time, mult: 1) },
+      "t" => Function.new("timestamp X") { |rt| rt.runtime.timestamp(10) },
+      "ts" => Function.new("timestamp Xs") { |rt| rt.runtime.timestamp(10, mult: 1) },
+      "T" => Function.new("timestamp X") { |rt| rt.runtime.timestamp(10, now: rt.time) },
+      "Ts" => Function.new("timestamp Xs") { |rt| rt.runtime.timestamp(10, now: rt.time, mult: 1) },
+      "x" => Function.new("timestamp X") { |rt| rt.runtime.timestamp(16) },
+      "xs" => Function.new("timestamp Xs") { |rt| rt.runtime.timestamp(16, mult: 1) },
+      "X" => Function.new("timestamp X") { |rt| rt.runtime.timestamp(16, now: rt.time) },
+      "Xs" => Function.new("timestamp Xs") { |rt| rt.runtime.timestamp(16, now: rt.time, mult: 1) },
+
+      # Randomness
+      "rd" => Function.new("random rd") { |rt| rt.runtime.random_rd },
+      "rx" => Function.new("random rx") { |rt| rt.runtime.random_hex },
+      "Rd" => Function.new("random Rd") { |_rt| format "%04d", SecureRandom.random_number(10_000) },
+      "Rx" => Function.new("random Rx") { |_rt| SecureRandom.hex },
+    }
+
+    # Names only available inside of S-Expressions
+    DefinedFunctions = {
+      "ext" => Function.new("ext") { |*args| Predefined.file_extension(*args) },
+      "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) },
+      "se" => Function.new("se") { |*args| Predefined::Shell.se(*args) },
+    }
+
+
+    AllFunctions = DefinedFields.merge(DefinedFunctions)
+
+
+    class << self
+      def get_field(name)
+        DefinedFields.fetch(name)
+      end
+
+      def get_function(name)
+        AllFunctions.fetch(name) do
+          Function.new("fallback to #{name}") do |rt, rcv, *args|
+            rcv.send(name, *args)
+          rescue NoMethodError
+            rcv.to_i.send(name, *args)
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/parsing/chunk_parser.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal true
+
+require_relative '../ast'
+require_relative 'input'
+require_relative 'parse_state'
+require_relative 'rgx_parsers'
+require 'l43/simple_color'
+
+# class MatchData
+#   def deconstruct_keys(*a)
+#     require "debug"; binding.break
+#     [self, $&.length]
+#   end
+# end
+
+module L43Rmap
+  module Parsing
+    class ChunkParser
+      include Ast
+      include L43::SimpleColor
+      include RgxParsers
+
+      SyntaxError = Class.new(RuntimeError)
+
+      def parse(input, pos: 1)
+        input = Input.new(current: input, pos:)
+        ast = []
+        loop do
+          # dbg("MAIN LOOP>>>", ast: ast.map(&:to_h), input: input.current)
+          return ast if input.empty?
+          result = parse_chunk(input)
+          result => chunk, input
+          # dbg("MAIN LOOP <<", ast: ast.map(&:to_h), chunk: chunk.to_h, input: input.current)
+          ast = unify_verb(ast << chunk)
+          # dbg("MAIN LOOP<<<", ast: ast.map(&:to_h), input: input.current)
+        end
+      end
+
+      def parse_chunk(input)
+        # p(input:)
+        if chunk = ZerofieldParser.parse(input)
+          chunk
+        elsif chunk = IndexedFieldParser.parse(input)
+          # dbg("FieldParser", chunk:)
+          chunk
+        elsif chunk = NoMetaParser.parse(input)
+          chunk
+        elsif chunk = EscapeParser.parse(input)
+          chunk
+        elsif chunk = NamedFieldParser.parse(input)
+          chunk
+        elsif LparParser.parse(input) in _, input
+          result = parse_sexp(input)
+          # p(result)
+          # dbg("MAIN <sexp", ast: result.first)
+          result
+        else
+          raise SyntaxError, input.to_h.inspect
+        end
+      end
+
+      private
+      def parse_dquoted_str(input, ast = String.new)
+        return nil unless DquoteParser.parse(input) in _, input
+
+        loop do
+          return if input.empty?
+
+          if EscDquoteParser.parse(input) in _, input
+            ast << '"' 
+          elsif DquoteParser.parse(input) in _, input
+            return [Str.new(ast), input]
+          end
+           
+          if NoDquoteParser.parse(input) in str, input
+            ast << str
+          end
+        end
+      end
+
+      def parse_squoted_str(input, ast = String.new)
+        return nil unless SquoteParser.parse(input) in _, input
+
+
+        loop do
+          return if input.empty?
+
+          if EscSquoteParser.parse(input) in _, input
+            ast << "'"
+          elsif SquoteParser.parse(input) in _, input
+            return [Str.new(ast), input]
+          end
+           
+          if NoSquoteParser.parse(input) in str, input
+            ast << str
+          end
+        end
+      end
+
+      def parse_sexp(input, level: 1)
+        # p(level:)
+        ast =[]
+        # dbg('SEXP >>>', level:, ast: ast.map(&:to_h), input: input.current)
+        stack << input.pos
+        loop do
+          # p(ast: ast.map(&:to_h), input: input.current)
+          if RparParser.parse(input) in _, input
+            stack.pop
+             # dbg('SEXP <<<', level:, s_exp: ast.map(&:value), stack:)
+            result = [Sexp.new(ast), input]
+            # p(level:, result:)
+            return result
+            # return [sexp(ast), input]
+          elsif LparParser.parse(input) in _, input
+            parse_sexp(input, level: level.succ) => result, input
+             # dbg('SEXP >>', level:, s_exp: result.value, stack:)
+             ast << result
+             # dbg('PUSHING', ast:)
+          elsif WsParser.parse(input) in _, input
+            nil
+          elsif IntParser.parse(input) in int, input
+            ast << int
+          elsif ZerofieldInsideParser.parse(input) in field, input
+            # p(ast: ast.map(&:to_h), field: field.to_h, input: input.to_h)
+            ast << field
+          elsif IndexedFieldParser.parse(input) in field, input
+            ast << field
+          elsif NamedFieldParser.parse(input) in fn, input
+            ast << fn
+          elsif OpParser.parse(input) in op, input
+            ast << op
+          elsif NameParser.parse(input) in name, input
+            # p(ast: ast.map(&:to_h))
+            # puts input.show
+            ast << name 
+          elsif parse_dquoted_str(input) in str, input
+            ast << str
+          elsif parse_squoted_str(input) in str, input
+            ast << str
+          elsif SymbolParser.parse(input) in bw, input
+            ast << bw
+          elsif BarewordParser.parse(input) in bw, input
+            ast << bw
+          else
+            raise SyntaxError, "bad S-EXP: #{input.show}"
+          end
+        end
+      end
+
+      def unify_verb(ast)
+        case ast
+        in [*head, {type: :verb, value: left}, {type: :verb, value: right}]
+          [*head, Verb.new(left + right)]
+        else
+          ast
+        end
+      end
+
+      #
+      # Memos and temporary code
+      # ========================
+
+      def stack = @__stack__ ||= []
+
+      def dbg(label, **vals)
+        putcol(:green__b, format("%-10s", label), :r, :magenta, " #{vals.inspect}")
+      end
+    end
+  end
+end
+  # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/parsing/input.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'l43/open_object'
+module L43Rmap
+  module Parsing
+    class Input
+      extend L43::OpenObject
+      attributes :current, pos: 1, parsed: String.new do |atts|
+        {current: current.dup}
+      end
+
+      def advance(by=1)
+        by = by.length if String === by
+        update(
+          current: current.slice(by..) || '',
+          parsed: parsed << current.slice(0...by),
+          pos: pos + by)
+      end
+
+      def empty? = current == ''
+
+      def show(n=10) = [current[0...n].inspect, pos].join(" at position:")
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/parsing/parse_state.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'l43/open_object'
+module L43Rmap
+  module Parsing
+    class ParseState
+      extend L43::OpenObject
+      attributes :input, ast: []
+
+      def deconstruct(*) = [ast, input]
+
+      def show
+        $stderr.puts({ast: ast.map(&:to_h), input: input.current}.inspect)
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/parsing/rgx_parser.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'parse_state'
+class MatchData
+  def deconstruct(*)
+    [to_s, *captures]
+  end
+end
+
+module L43Rmap
+  module Parsing
+    class RgxParser
+      BadRgx = Class.new(RuntimeError)
+      attr_reader :blk, :only_group, :rgx
+
+      def parse(input)
+        match = rgx.match(input.current)
+        # p(rgx:, input:, match:) if ENV['DEBUG']
+        # p(match:) if match
+        case match
+        in nil
+          nil
+        in [m]
+          ParseState.new(ast: postprocess(m), input: advance(input, m, m))
+        in [m, a]
+          ParseState.new(ast: postprocess(a), input: advance(input, a, m))
+        in [_, *rest]
+          raise BadRgx, "too many captures; max = 1, had #{rest.count}"
+        end
+      end
+
+      private
+      def initialize(rgx, only_group: false, &blk)
+        @blk = blk
+        @only_group = only_group
+        @rgx = rgx
+      end
+
+      def advance(input, a, m) 
+        if only_group 
+          input.advance(a)
+        else
+          input.advance(m)
+        end
+      end
+
+      def postprocess(a) = blk ? blk.(a) : a
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later