l43_rmap 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d55c3692c807fd46a368f265ddfb492640c44e134cfcd56660d831482612191e
-  data.tar.gz: 25c329e6544381cb52b5b386e7fe73d62c00c14d9e7179de9f324a952846f4a2
+  metadata.gz: 27b3cc1e893f020ac4ddac1a4e58ed9bf6f839d3bbd688f0afc9f5b284f518e1
+  data.tar.gz: 1ba30b1149bb306e419f380a55d0b801d01926b6513e828f7e50469b3bb10d13
 SHA512:
-  metadata.gz: 99ba2278ccd9f935472b12b4c983147255e3daeebfc3084000e6229a86db1fd7c8b71fb544b04707d171517ee7bb46e364955a711613e13e3793099d7c513319
-  data.tar.gz: 966bc037f9c52c256debfc74682e8b05ce2bf90bc9381afc54a808dff5d912e10caef3628b6fb03410b825433c3e42ab123dce78cc3924329ff71599e62cf36f
+  metadata.gz: 29dff91cc35c9f721c5dd46c4b0ad526df91a403843f96153fb567bc3113df74a45cf0e32edee5da92935aa068ef093c92d969f08efce5f1aa3da517e24714b8
+  data.tar.gz: 3c04d57c6b251897fabf78ffcb91249ebb166bc6c74523cdb8976203faafe85cd9675238a9d9ca99851ec5ffa0681b5b9f074bd380dc91e521e1fbb13a327be4

data/lib/l43_rmap/ast.rb

@@ -13,6 +13,13 @@ module L43Rmap
         super(value:, type: :bareword)
       end
     end
+    class FieldRange < Node
+      def initialize(first, last)
+        first = first.pred if first > 0
+        last = last.pred if last > 0
+        super(value: first..last, type: :field_range)
+      end
+    end
     class IndexedField < Node
       def initialize(value)
         super(value:, type: :indexed_field)

data/lib/l43_rmap/cli/help.rb

@@ -65,6 +65,8 @@ module L43Rmap
         putcol
         putcol(:bold, :blue, "predefined patterns", :white, " are the following:")
         putcol
+        putcol(4, :bold, :magenta, "date_grep", :white, ":", :blue, "<date-range>", :white, " same as ", arg1("(if (fin % <date-range>) % :ignore)"))
+        putcol(4, :bold, :magenta, "date_grep", :white, ":", :blue, "<subject>,<date-range>", :white, " same as ", arg1("(if (fin <subject> <date-range>) <subject> :ignore)"))
         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)")

data/lib/l43_rmap/cli.rb

@@ -40,10 +40,13 @@ module L43Rmap
         .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")])
         .flag(:version, :v, desc: ["Just print current version ",dimmed(version_string)], stop: true)
         .section("Options")
-        .keyword(:input, :i, desc: ["file to read from, defaults to ", :bold, :cyan, '$stdin'], default: $stdin)
+        .keyword(:glob, :g, desc: ["do not read from ", :bold, :cyan, "<input>", :reset, " but reads the names of the expanded ", :bold, :blue, "<glob>", :reset, :dim,
+                                   ". Conflicts with ", :bold, :blue, "input: "], default: nil)
+        .keyword(:input, :i, desc: ["file to read from, defaults to ", :bold, :cyan, '$stdin'], default: nil)
         .keyword(:limit, :l, desc:["if specified, limits output to the given value of lines, it is applied, ", :bold, "after", :reset, " randomization (if applicable)"], default: nil, &:to_i)
         .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)
+        .post_check('must not provide input: and glob:') { !(it.glob && it.input) }
     end
 
     def _compile 
@@ -51,23 +54,23 @@ module L43Rmap
     end
 
     def _run 
-      runtime.run(kwds.input, kwds.output, randomize: kwds.randomize)
+      runtime.run(input, kwds.output, randomize: kwds.randomize)
       :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
+      if pattern && kwds.pattern
+        puterr("must not have positonal arg as ", :blue, :bold, "pattern", :white, " and", kwd("pattern"))
+        puthint
+        false
+      else
+        @pattern = pattern || kwds.pattern || "%"
+      end
     end
 
     def check_pattern
-      return true unless kwds.pattern
-      puterr("must not have positonal arg as ", :blue, :bold, "pattern", :white, " and", kwd("pattern"))
-      puthint
+      return :ok unless kwds.pattern
     end
       
     def compiled
@@ -102,6 +105,13 @@ module L43Rmap
       putcol(:blue, :bold, {args:}.inspect)
       :ok
     end
+
+    def input
+      return Dir.glob(kwds.glob).lazy.filter { File.file?(it) } if kwds.glob
+
+      kwds.input || $stdin
+    end
+
     def replace_pattern_if_predefined
       return unless kwds.pattern
       @pattern = PredefinedPatterns.get_pattern(kwds.pattern)

data/lib/l43_rmap/compiler.rb

@@ -21,6 +21,8 @@ module L43Rmap
         compile_function(value)
       in {type: :indexed_field, value:}
         compile_field(value)
+      in {type: :field_range, value:}
+        compile_field_range(value)
       in {type: :sexp, value:}
         compile_sexp(value)
       in {type: :str, value:}
@@ -36,6 +38,10 @@ module L43Rmap
       compile_subfield value.pred
     end
 
+    def compile_field_range(range)
+      Function.new("field range #{range}") { |rt| rt.fields[range]&.join(" ") || "" }
+    end
+
     def compile_function(name)
       Functions.get_field(name)
       # TODO: Fallbacks

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+require_relative '../../tools/time'
+module L43Rmap
+  module Functions
+    module Predefined
+      module Files extend self
+        def bn(rt, *args)
+          case args
+          in []
+            File.basename(rt.line)
+          in [fn]
+            File.basename(fn.to_s)
+          else
+            raise ArgumentError, "bn supports at most 1 argument #{args.inspect}"
+          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 supports at most 1 argument #{args.inspect}"
+          end
+        end
+
+        def file_in(rt, *args)
+          case args
+          in []
+            raise ArgumentError, "fin needs at least 1 argument"
+          in [time]
+            _file_in(rt.line, time)
+          in [file, time]
+            _file_in(file, time)
+          else
+            raise ArgumentError, "fin supports at most 2 arguments #{args.inspect}"
+          end
+        end
+
+        private
+        def _file_in(file, time)
+          mtime = File.lstat(file).mtime.utc
+          time_range = Tools::Time.range_from_string(time.to_s)
+          result = Tools::Time.in_range(mtime, time_range)
+          # p(file: File.basename(file), mtime: mtime.iso8601, time:, start: time_range.start.iso8601, result:)
+          result
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

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

@@ -5,6 +5,7 @@ module L43Rmap
     module Predefined
       module Shell extend self
         def se(rt, *args)
+          require 'shellwords'
           case args
           in []
             rt.line.shellescape

data/lib/l43_rmap/functions/predefined.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../evaluator/evaluations'
+require_relative 'predefined/files'
 require_relative 'predefined/shell'
 require_relative 'predefined/str'
 
@@ -28,17 +29,6 @@ module L43Rmap
           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 unless_fn(_rt, cond, false_branch, true_branch=nil)
           if cond
             true_branch

data/lib/l43_rmap/functions.rb

@@ -40,7 +40,9 @@ module L43Rmap
       "unless" => Function.new("unless") { |*args| Predefined.unless_fn(*args) },
 
       # File
-      "ext" => Function.new("ext") { |*args| Predefined.file_extension(*args) },
+      "bn" => Function.new("bn") { |*args| Predefined::Files.bn(*args) },
+      "ext" => Function.new("ext") { |*args| Predefined::Files.file_extension(*args) },
+      "fin" => Function.new("ext") { |*args| Predefined::Files.file_in(*args) },
 
       # Int
       "inc" => Function.new("inc") { |*args| Predefined.inc(*args) },

data/lib/l43_rmap/parsing/chunk_parser.rb

@@ -40,6 +40,8 @@ module L43Rmap
         # p(input:)
         if chunk = ZerofieldParser.parse(input)
           chunk
+        elsif chunk = FieldRangeParser.parse(input)
+          chunk
         elsif chunk = IndexedFieldParser.parse(input)
           # dbg("FieldParser", chunk:)
           chunk

data/lib/l43_rmap/parsing/rgx_parser.rb

@@ -24,6 +24,8 @@ module L43Rmap
           ParseState.new(ast: postprocess(m), input: advance(input, m, m))
         in [m, a]
           ParseState.new(ast: postprocess(a), input: advance(input, a, m))
+        in [m, a, b]
+          ParseState.new(ast: postprocess2(a, b), input: advance(input, a, m))
         in [_, *rest]
           raise BadRgx, "too many captures; max = 1, had #{rest.count}"
         end
@@ -45,6 +47,7 @@ module L43Rmap
       end
 
       def postprocess(a) = blk ? blk.(a) : a
+      def postprocess2(a, b) = blk ? blk.(a, b) : [a, b]
     end
   end
 end

data/lib/l43_rmap/parsing/rgx_parsers.rb

@@ -21,6 +21,9 @@ module L43Rmap
       ESCAPE     = /\A%([%(])/
       EscapeParser = RgxParser.new(ESCAPE) { Verb.new(it) }
 
+      FIELD_RANGE = /\A%(-?\d+)-(-?\d+)/
+      FieldRangeParser = RgxParser.new(FIELD_RANGE) { |a, b| FieldRange.new(a.to_i, b.to_i) }
+
       INDEXED_FIELD      = /\A%([-+]?\d+) ?/
       IndexedFieldParser = RgxParser.new(INDEXED_FIELD) { IndexedField.new(it.to_i) }
 

data/lib/l43_rmap/predefined_patterns.rb

@@ -4,12 +4,32 @@ module L43Rmap
   module PredefinedPatterns extend self
     
     Patterns = {
+      date_grep: '(if (fin $2 "$1") $2 :ignore)', 
       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)',
+
     }
       
-    def get_pattern(key) = Patterns.fetch(key.to_sym)
+    def get_pattern(key)
+      key.split(":", 2) => key, *args
+      pattern = Patterns.fetch(key.to_sym)
+      case args
+      in []
+        pattern
+      else
+        pattern_with_arg(pattern, args.first.split(","))
+      end
+    end
+
+    private
+    def pattern_with_arg(pattern, args)
+      args << "%"
+      args.take(2).each_with_index.inject(pattern) do |pattern, (arg, idx)|
+        pat = /(?<!\$)\$#{idx.succ}(?!\d)/
+        pattern.gsub(pat, arg)
+      end
+    end
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/runtime.rb

@@ -24,7 +24,7 @@ module L43Rmap
     def random_hex =  @__randomhex__ ||= SecureRandom.hex
 
     def random_rd =  @__randomrd__ ||= (format "%04d", SecureRandom.random_number(DefaultDecRandomMax))
-      
+
     def image = chunks.map(&:image).join("\n")
 
     def terminate! = @terminated = true
@@ -38,10 +38,9 @@ module L43Rmap
 
     private
     def execute!
-      lnb = 0
       loop do
-        line = input_stream.readline chomp: true
-        lnb = lnb + 1
+        input_stream.next => line, idx
+        lnb = idx.succ 
         @current = LineTime.new(line:, lnb:, runtime: self)
         result = current.run
         # p(transformed: result)
@@ -58,18 +57,37 @@ module L43Rmap
           raise "BAD RETURN FROM LineTime: #{result.inspect}"
         end
       end
+      maybe_output_buffer
     end
 
     def initialize(chunks, limit: nil)
       @chunks = chunks
       @limit = limit || -1
     end
-      
+
     def make_input_stream(stream)
-      return stream unless String === stream
-      File.open(stream)
+      case stream
+      when Array
+        stream.lazy.with_index
+      when String
+        File.foreach(stream, chomp: true).with_index
+      when Enumerator::Lazy
+        stream.with_index
+      else
+        make_generic_input_stream(stream)
+      end
+    end
+
+    def make_generic_input_stream(stream)
+      Enumerator.new do |y|
+        loop do
+          y << stream.readline(chomp: true)
+        end
+      rescue EOFError
+        raise StopIteration, "EOF of #{stream}"
+      end.with_index
     end
-      
+
     def make_output_stream(stream)
       return stream unless String === stream
       File.open(stream, 'w')
@@ -81,11 +99,21 @@ module L43Rmap
       sorted = output_buffer
         .sort_by { rand }
       # p(sorted:)
-        sorted.each do
-          raise EOFError, "limit reached" if limit.zero?
-          @limit -= 1
-          output_stream << it
-          output_stream << "\n"
+      sorted.each do
+        raise EOFError, "limit reached" if limit.zero?
+        @limit -= 1
+        output_stream << it
+        output_stream << "\n"
+      end
+    end
+
+    def next_line
+      @__reader__ ||=
+        case input
+        when Enumerator
+          -> { input.next }
+        else
+          -> { input.readline chomp: true }
         end
     end
 
@@ -97,6 +125,7 @@ module L43Rmap
       else
         raise EOFError, "limit reached" if limit.zero?
         @limit -= 1
+        # p(line:)
         output_stream << line
         output_stream << "\n" 
       end

data/lib/l43_rmap/tools/time/rgx.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module L43Rmap
+  module Tools
+    module Time
+      module Rgx
+        def ndigits(n)
+          n = n - 4
+          rgx = [ "\\A",
+            "(\\d{2})",
+            "(\\d{2})",
+            *(n/2).times.map { "(\\d{2})?" },
+            "\\z"
+          ].join
+          Regexp.compile(rgx)
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/l43_rmap/tools/time.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'l43/open_object'
+
+require 'date'
+require_relative 'time/rgx'
+module L43Rmap
+  module Tools
+    module Time extend self
+      extend Rgx
+      Range = L43::OpenObject.def_class(:start, :stop)
+      BadTimeFormat = Class.new(RuntimeError)
+
+      def in_range(time, range)
+        time = time.to_time
+        left = (time >= range.start)
+        # p(time: time.iso8601, start: range.start.iso8601, left:)
+        left && (time <= range.stop)
+      end
+
+      def range_from_string(str)
+        case str.gsub(/[_T:]/, '').split(/(?:-|\.\.)/)
+        in [start]
+          _range_from_strings(start)
+        in [start, stop]
+          _range_from_strings(start, stop)
+        else
+          raise ArgumentError, "too many ranges in #{str}"
+        end
+      end
+
+      def time_from_string(str) = _mk_time(str)
+
+      private
+
+      YearMonthRgx = ndigits(12)
+
+      def _mk_time(str)
+        m = YearMonthRgx.match(str)
+        raise BadTimeFormat, "not a 4 to 12 digit even length str #{str.inspect}" unless m
+        
+        m.captures.compact.map(&:to_i) => y, m, *rest
+
+        data = [2000 + y, m, *rest.take(4)]
+        # require "debug"; binding.break
+        DateTime.new(*data)
+      end
+
+      def _range_from_strings(startstr, stop=nil)
+        start = _mk_time(startstr)
+        stop = _complete_to_end(stop, start, startstr.length)
+        Range.new(
+          start: start.to_time,
+          stop: stop.to_time
+        )
+      end
+
+      def _complete_to_end(stop, start, len)
+
+        if stop
+          len = stop.length
+          start = _mk_time(stop) if stop
+        end
+
+        case len
+        when 4
+          start.next_month
+        when 6
+          start.next_day
+        when 8
+          start + 1r/24
+        when 10
+          start + 1r/1440
+        when 12
+          start + 1r/86400
+        end
+      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.4'
+  VERSION = '0.1.5'
 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.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Robert Dober
 bindir: bin
 cert_chain: []
-date: 2026-06-06 00:00:00.000000000 Z
+date: 2026-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ostruct
@@ -24,47 +24,61 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.6.3
 - !ruby/object:Gem::Dependency
-  name: l43_open_object
+  name: shellwords
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.2.2
 - !ruby/object:Gem::Dependency
-  name: l43_simple_color
+  name: l43_opt_parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.3
+        version: 0.3.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.3
+        version: 0.3.3
 - !ruby/object:Gem::Dependency
-  name: l43_peg
+  name: l43_open_object
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: l43_simple_color
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
 description: 'A hybrid between awk and grep
 
   '
@@ -90,6 +104,7 @@ files:
 - lib/l43_rmap/function.rb
 - lib/l43_rmap/functions.rb
 - lib/l43_rmap/functions/predefined.rb
+- lib/l43_rmap/functions/predefined/files.rb
 - lib/l43_rmap/functions/predefined/shell.rb
 - lib/l43_rmap/functions/predefined/str.rb
 - lib/l43_rmap/parsing/chunk_parser.rb
@@ -100,6 +115,8 @@ files:
 - lib/l43_rmap/predefined_patterns.rb
 - lib/l43_rmap/runtime.rb
 - lib/l43_rmap/runtime/line_time.rb
+- lib/l43_rmap/tools/time.rb
+- lib/l43_rmap/tools/time/rgx.rb
 - lib/l43_rmap/version.rb
 homepage: https://codeberg.org/lab419/rmap
 licenses: