jrf 0.1.11 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edaeb729eecf63449c68fce92740acb8221885ff28a5ed26fe7bea32eb0a9bfa
-  data.tar.gz: 30364ac5e6eee46506da8c4d3ff2d8a05f12cd91b2b5cd248a12e612ea333891
+  metadata.gz: 2862eaf6bd5f2486ea2c6aebf5caa4fbc2de56f419625bf8bb462392a3ea5dd9
+  data.tar.gz: 3f29e7024f4e33606d78ad01ce4c45f37c9cd652ba94ac490866cd877368037a
 SHA512:
-  metadata.gz: 22e73015ffb398d376c3636f8a9e324c01bd56ae5dc1170b39a8ad5c600c10273fadec1de5385706798e3aff19449b446744e608f1437ca73113871c33aa9b1b
-  data.tar.gz: 4c803ad64d65d6ae1d671426c2e81a4741ebcebd66ca4fb288574336e0a1088b8be2aa78f4235213ffc5794c92877410c88cbce7dae1f88bfb6369f6f37e3970
+  metadata.gz: 04f55e0ea8c24f70126964beffbe80bee1800e1e210da2f96186bb8ebdf5542e5dfbab9c06b48624da4ec35912d02456561ec6c0d2c66c094de001ecf7f4096f
+  data.tar.gz: '093821f35539be4561867b711664a31d3441052fe53e1c0f73489cd8b11fdf845bfb5573375f880ce07cd73ffc2f1d0514b55b760227c01ab515afd39d8ac08a'

data/jrf.gemspec

@@ -16,6 +16,8 @@ Gem::Specification.new do |spec|
   spec.bindir = "exe"
   spec.executables = ["jrf"]
   spec.add_dependency "oj", ">= 3.16"
+  spec.add_development_dependency "minitest", ">= 5.0"
+  spec.add_development_dependency "rake", ">= 13.0"
 
   spec.files = Dir.glob("{exe,lib,test}/*") + Dir.glob("lib/**/*") + %w[DESIGN.txt jrf.gemspec Gemfile Rakefile].select { |path| File.file?(path) }
 end

data/lib/jrf/cli/runner.rb

@@ -28,12 +28,12 @@ module Jrf
         end
       end
 
-      def initialize(inputs:, out: $stdout, err: $stderr, lax: false, pretty: false, atomic_write_bytes: DEFAULT_OUTPUT_BUFFER_LIMIT)
+      def initialize(inputs:, out: $stdout, err: $stderr, lax: false, output_format: :json, atomic_write_bytes: DEFAULT_OUTPUT_BUFFER_LIMIT)
         @inputs = inputs
         @out = out
         @err = err
         @lax = lax
-        @pretty = pretty
+        @output_format = output_format
         @atomic_write_bytes = atomic_write_bytes
         @output_buffer = +""
       end
@@ -49,8 +49,13 @@ module Jrf
         pipeline = Pipeline.new(*blocks)
 
         input_enum = Enumerator.new { |y| each_input_value { |v| y << v } }
-        pipeline.call(input_enum) do |value|
-          emit_output(value)
+
+        if @output_format == :tsv
+          values = []
+          pipeline.call(input_enum) { |value| values << value }
+          emit_tsv(values)
+        else
+          pipeline.call(input_enum) { |value| emit_output(value) }
         end
       ensure
         write_output(@output_buffer)
@@ -109,7 +114,54 @@ module Jrf
       end
 
       def emit_output(value)
-        record = (@pretty ? JSON.pretty_generate(value) : JSON.generate(value)) << "\n"
+        record = (@output_format == :pretty ? JSON.pretty_generate(value) : JSON.generate(value)) << "\n"
+        buffer_output(record)
+      end
+
+      def emit_tsv(values)
+        rows = values.flat_map { |value| value_to_rows(value) }
+        rows.each do |row|
+          buffer_output(row.join("\t") << "\n")
+        end
+      end
+
+      def value_to_rows(value)
+        case value
+        when Hash
+          value.map { |k, v|
+            case v
+            when Array
+              [format_cell(k)] + v.map { |e| format_cell(e) }
+            else
+              [format_cell(k), format_cell(v)]
+            end
+          }
+        when Array
+          value.map { |row|
+            case row
+            when Array
+              row.map { |e| format_cell(e) }
+            else
+              [format_cell(row)]
+            end
+          }
+        else
+          [[format_cell(value)]]
+        end
+      end
+
+      def format_cell(value)
+        case value
+        when nil
+          "null"
+        when Numeric, String, true, false
+          value.to_s
+        else
+          JSON.generate(value)
+        end
+      end
+
+      def buffer_output(record)
         if @output_buffer.bytesize + record.bytesize <= @atomic_write_bytes
           @output_buffer << record
         else

data/lib/jrf/cli.rb

@@ -16,7 +16,8 @@ module Jrf
       Options:
         -v, --verbose  print parsed stage expressions
         --lax          allow multiline JSON texts; split inputs by whitespace (also detects JSON-SEQ RS 0x1e)
-        -p, --pretty   pretty-print JSON output instead of compact NDJSON
+        -o, --output FORMAT
+                       output format: json (default), pretty, tsv
         -r, --require LIBRARY
                        require LIBRARY before evaluating stages
         --no-jit       do not enable YJIT, even when supported by the Ruby runtime
@@ -43,7 +44,7 @@ module Jrf
     def self.run(argv = ARGV, input: ARGF, out: $stdout, err: $stderr)
       verbose = false
       lax = false
-      pretty = false
+      output_format = :json
       jit = true
       required_libraries = []
       atomic_write_bytes = Runner::DEFAULT_OUTPUT_BUFFER_LIMIT
@@ -52,7 +53,7 @@ module Jrf
           opts.banner = USAGE
           opts.on("-v", "--verbose", "print parsed stage expressions") { verbose = true }
           opts.on("--lax", "allow multiline JSON texts; split inputs by whitespace (also detects JSON-SEQ RS 0x1e)") { lax = true }
-          opts.on("-p", "--pretty", "pretty-print JSON output instead of compact NDJSON") { pretty = true }
+          opts.on("-o", "--output FORMAT", %w[json pretty tsv], "output format: json, pretty, tsv") { |fmt| output_format = fmt.to_sym }
           opts.on("-r", "--require LIBRARY", "require LIBRARY before evaluating stages") { |library| required_libraries << library }
           opts.on("--no-jit", "do not enable YJIT, even when supported by the Ruby runtime") { jit = false }
           opts.on("--atomic-write-bytes N", Integer, "group short outputs into atomic writes of up to N bytes") do |value|
@@ -113,7 +114,7 @@ module Jrf
         out: out,
         err: err,
         lax: lax,
-        pretty: pretty,
+        output_format: output_format,
         atomic_write_bytes: atomic_write_bytes
       ).run(expression, verbose: verbose)
     end

data/lib/jrf/row_context.rb

@@ -59,6 +59,10 @@ module Jrf
       end
     end
 
+    define_reducer(:count_if) do |_ctx, condition, block: nil|
+      { value: condition, initial: 0, step: ->(acc, v) { v ? (acc + 1) : acc } }
+    end
+
     define_reducer(:min) do |_ctx, value, block: nil|
       { value: value, initial: nil, step: ->(acc, v) { v.nil? ? acc : (acc.nil? || v < acc ? v : acc) } }
     end
@@ -170,16 +174,22 @@ module Jrf
       @__jrf_current_stage.step_reduce(current_input, initial: initial, &block)
     end
 
-    def map(&block)
+    def map(collection = nil, &block)
       raise ArgumentError, "map requires a block" unless block
 
-      @__jrf_current_stage.step_map(:map, current_input, &block)
+      @__jrf_current_stage.step_map(:map, collection || current_input, &block)
     end
 
-    def map_values(&block)
+    def map_values(collection = nil, &block)
       raise ArgumentError, "map_values requires a block" unless block
 
-      @__jrf_current_stage.step_map(:map_values, current_input, &block)
+      @__jrf_current_stage.step_map(:map_values, collection || current_input, &block)
+    end
+
+    def apply(collection = nil, &block)
+      raise ArgumentError, "apply requires a block" unless block
+
+      @__jrf_current_stage.step_apply(collection || current_input, &block)
     end
 
     def group_by(key, &block)

data/lib/jrf/stage.rb

@@ -113,6 +113,35 @@ module Jrf
       ReducerToken.new(idx)
     end
 
+    def step_apply(collection, &block)
+      raise TypeError, "apply expects Array, got #{collection.class}" unless collection.is_a?(Array)
+
+      apply_reducers = []
+      template = nil
+      results = []
+
+      collection.each do |v|
+        with_scoped_reducers(apply_reducers) do
+          result = @ctx.send(:__jrf_with_current_input, v) { block.call(v) }
+          template ||= result
+          results << result
+        end
+      end
+
+      if apply_reducers.any?
+        self.class.resolve_template(template, apply_reducers)
+      else
+        results.each_with_object([]) do |mapped, arr|
+          next if mapped.equal?(Control::DROPPED)
+          if mapped.is_a?(Control::Flat)
+            arr.concat(Array(mapped.value))
+          else
+            arr << mapped
+          end
+        end
+      end
+    end
+
     def step_group_by(key, &block)
       idx = @cursor
       map_reducer = (@reducers[idx] ||= MapReducer.new(:group_by, false))

data/lib/jrf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Jrf
-  VERSION = "0.1.11"
+  VERSION = "0.1.13"
 end