jrf 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edaeb729eecf63449c68fce92740acb8221885ff28a5ed26fe7bea32eb0a9bfa
-  data.tar.gz: 30364ac5e6eee46506da8c4d3ff2d8a05f12cd91b2b5cd248a12e612ea333891
+  metadata.gz: ddf9bb5a12260eea615d0107dc7374dec2b5a3fe81c51791ea7e7ffea359d12f
+  data.tar.gz: d556b7d230185a9c397af45abaa08b912f485f3a1494bebdf86f2ef44be81c64
 SHA512:
-  metadata.gz: 22e73015ffb398d376c3636f8a9e324c01bd56ae5dc1170b39a8ad5c600c10273fadec1de5385706798e3aff19449b446744e608f1437ca73113871c33aa9b1b
-  data.tar.gz: 4c803ad64d65d6ae1d671426c2e81a4741ebcebd66ca4fb288574336e0a1088b8be2aa78f4235213ffc5794c92877410c88cbce7dae1f88bfb6369f6f37e3970
+  metadata.gz: e7642e5e7c50e9b4da7f28bf906bf432ee7c6d377839af2ff2b73d299c044e08566876bd3d33d5492abe9432b58f0871df2ebb9d4e7ec45ffe02a495fad1e2fc
+  data.tar.gz: '0629e81b1c9cf8070fb0a1fcbe409cf026bb62f72da9855d32fe9f253552de51a21f663b616abdc3b474dd705d9067512838fe5f0e33293f423636a5ea18167f'

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.12"
 end

data/test/jrf_test.rb

@@ -534,6 +534,23 @@ stdout, stderr, status = run_jrf('count(_["foo"])', input_with_nil)
 assert_success(status, stderr, "count(expr) ignores nil")
 assert_equal(%w[2], lines(stdout), "count(expr) ignores nil output")
 
+# count_if
+input_count_if = <<~NDJSON
+  {"x":1}
+  {"x":-2}
+  {"x":3}
+  {"x":-4}
+  {"x":5}
+NDJSON
+
+stdout, stderr, status = run_jrf('count_if(_["x"] > 0)', input_count_if)
+assert_success(status, stderr, "count_if")
+assert_equal(%w[3], lines(stdout), "count_if output")
+
+stdout, stderr, status = run_jrf('[count_if(_["x"] > 0), count_if(_["x"] < 0)]', input_count_if)
+assert_success(status, stderr, "count_if multiple")
+assert_equal(["[3,2]"], lines(stdout), "count_if multiple output")
+
 input_all_nil = <<~NDJSON
   {"foo":null}
   {"bar":1}
@@ -855,6 +872,36 @@ stdout, stderr, status = run_jrf('map_values { |obj| map_values { |v| sum(v) } }
 assert_success(status, stderr, "nested map_values reducer binds to current target")
 assert_equal(['{"a":{"x":4,"y":6},"b":{"x":40,"y":60}}'], lines(stdout), "nested map_values reducer output")
 
+# apply - aggregation
+stdout, stderr, status = run_jrf('[apply { |x| sum(x["foo"]) }, _.length]', '[{"foo":1},{"foo":2}]' + "\n" + '[{"foo":10}]' + "\n")
+assert_success(status, stderr, "apply with sum")
+assert_equal(["[3,2]", "[10,1]"], lines(stdout), "apply with sum output")
+
+# apply - passthrough
+stdout, stderr, status = run_jrf('apply { |x| x["foo"] }', '[{"foo":1},{"foo":2}]' + "\n")
+assert_success(status, stderr, "apply passthrough")
+assert_equal(["[1,2]"], lines(stdout), "apply passthrough output")
+
+# apply - percentile
+stdout, stderr, status = run_jrf('apply { |x| percentile(x, 0.5) }', '[10,20,30]' + "\n")
+assert_success(status, stderr, "apply with percentile")
+assert_equal(["20"], lines(stdout), "apply with percentile output")
+
+# apply with explicit collection inside map
+stdout, stderr, status = run_jrf('map { |o| [apply(o["vals"]) { |x| sum(x) }, o["name"]] }', '[{"name":"a","vals":[1,2]},{"name":"b","vals":[10,20]}]' + "\n")
+assert_success(status, stderr, "apply with explicit collection")
+assert_equal(['[[3,"a"],[30,"b"]]'], lines(stdout), "apply with explicit collection output")
+
+# map with explicit collection
+stdout, stderr, status = run_jrf('map(_["items"]) { |x| x * 2 }', '{"items":[1,2,3]}' + "\n")
+assert_success(status, stderr, "map with explicit collection")
+assert_equal(["[2,4,6]"], lines(stdout), "map with explicit collection output")
+
+# map_values with explicit collection
+stdout, stderr, status = run_jrf('map_values(_["data"]) { |v| v * 10 }', '{"data":{"a":1,"b":2}}' + "\n")
+assert_success(status, stderr, "map_values with explicit collection")
+assert_equal(['{"a":10,"b":20}'], lines(stdout), "map_values with explicit collection output")
+
 input_gb = <<~NDJSON
   {"status":200,"path":"/a","latency":10}
   {"status":404,"path":"/b","latency":50}
@@ -976,6 +1023,30 @@ assert_equal([[["a", 1], ["b", 2]]], j.call([{"a" => 1, "b" => 2}]), "library ma
 j = Jrf.new(proc { map { |k, v| sum(v + k.length) } })
 assert_equal([[5, 7]], j.call([{"a" => 1, "b" => 2}, {"a" => 2, "b" => 3}]), "library map hash reduce")
 
+# apply - aggregation
+j = Jrf.new(proc { [apply { |x| sum(x["foo"]) }, _.length] })
+assert_equal([[3, 2], [10, 1]], j.call([[{"foo" => 1}, {"foo" => 2}], [{"foo" => 10}]]), "library apply reducer")
+
+# apply - passthrough
+j = Jrf.new(proc { apply { |x| x["foo"] } })
+assert_equal([[1, 2]], j.call([[{"foo" => 1}, {"foo" => 2}]]), "library apply passthrough")
+
+# apply - percentile
+j = Jrf.new(proc { apply { |x| percentile(x, 0.5) } })
+assert_equal([20], j.call([[10, 20, 30]]), "library apply percentile")
+
+# apply with explicit collection inside map
+j = Jrf.new(proc { map { |o| [apply(o["vals"]) { |x| sum(x) }, o["name"]] } })
+assert_equal([[[3, "a"], [30, "b"]]], j.call([[{"name" => "a", "vals" => [1, 2]}, {"name" => "b", "vals" => [10, 20]}]]), "library apply explicit collection")
+
+# map with explicit collection
+j = Jrf.new(proc { map(_["items"]) { |x| x * 2 } })
+assert_equal([[2, 4, 6]], j.call([{"items" => [1, 2, 3]}]), "library map explicit collection")
+
+# map_values with explicit collection
+j = Jrf.new(proc { map_values(_["data"]) { |v| v * 10 } })
+assert_equal([{"a" => 10, "b" => 20}], j.call([{"data" => {"a" => 1, "b" => 2}}]), "library map_values explicit collection")
+
 # group_by
 j = Jrf.new(proc { group_by(_["k"]) { count() } })
 assert_equal([{"x" => 2, "y" => 1}], j.call([{"k" => "x"}, {"k" => "x"}, {"k" => "y"}]), "library group_by")

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jrf
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.1.12
 platform: ruby
 authors:
 - kazuho
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-03-12 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -49,11 +48,9 @@ files:
 - lib/jrf/stage.rb
 - lib/jrf/version.rb
 - test/jrf_test.rb
-homepage: 
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -68,8 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 4.0.3
 specification_version: 4
 summary: JSON filter with the power and speed of Ruby
 test_files: []