jrf 0.1.10 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a42d35a082e26fb5ebc35733d705169793e42491eb20040aff884f65e016cf7
-  data.tar.gz: 909ac3ea12a5bf4bf805ea65d25f03e01843efcc944a0180cda90d8d8dd89b8f
+  metadata.gz: ddf9bb5a12260eea615d0107dc7374dec2b5a3fe81c51791ea7e7ffea359d12f
+  data.tar.gz: d556b7d230185a9c397af45abaa08b912f485f3a1494bebdf86f2ef44be81c64
 SHA512:
-  metadata.gz: e38ba5d6ec1ae98cefe2d9ce848d3702ba2bddb6f2858df0b9055da84c08dd3371a1b3d6290ae74796b858765c5af5cbc4c68180fde6b161b78cbbefdfdbc84d
-  data.tar.gz: cd5e4a2f2d93b34a45c3121e021b9ca23974476b82e3169f17ed6bce44600ecc82bcb5dc35cf3fc52cafb5749dd8be21370f7e5f2c33031774619f416e3c3518
+  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, @obj, &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, @obj, &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.10"
+  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}
@@ -847,6 +864,44 @@ stdout, stderr, status = run_jrf('_["values"] >> map { |x| x + 1 } >> map { |x|
 assert_success(status, stderr, "chained map transforms")
 assert_equal(['[20,110,1010]', '[30,210,2010]', '[40,310,3010]'], lines(stdout), "chained map transforms output")
 
+stdout, stderr, status = run_jrf('map { map { |y| [ sum(y[0]), sum(y[1]) ] } }', "[[[1,2]]]\n[[[3,4]]]\n")
+assert_success(status, stderr, "nested map reducer binds to current target")
+assert_equal(['[[[4,6]]]'], lines(stdout), "nested map reducer output")
+
+stdout, stderr, status = run_jrf('map_values { |obj| map_values { |v| sum(v) } }', "{\"a\":{\"x\":1,\"y\":2},\"b\":{\"x\":10,\"y\":20}}\n{\"a\":{\"x\":3,\"y\":4},\"b\":{\"x\":30,\"y\":40}}\n")
+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}
@@ -944,10 +999,18 @@ assert_equal([[2, 3], [4, 5]], j.call([[1, 2], [3, 4]]), "library map transform"
 j = Jrf.new(proc { map { |x| sum(x) } })
 assert_equal([[4, 6]], j.call([[1, 2], [3, 4]]), "library map reduce")
 
+# nested map reduce binds to current target
+j = Jrf.new(proc { map { map { |y| [sum(y[0]), sum(y[1])] } } })
+assert_equal([[[[4, 6]]]], j.call([[[[1, 2]]], [[[3, 4]]]]), "library nested map reduce")
+
 # map_values transform
 j = Jrf.new(proc { map_values { |v| v * 10 } })
 assert_equal([{"a" => 10, "b" => 20}], j.call([{"a" => 1, "b" => 2}]), "library map_values transform")
 
+# nested map_values reduce binds to current target
+j = Jrf.new(proc { map_values { |obj| map_values { |v| sum(v) } } })
+assert_equal([{"a" => {"x" => 4, "y" => 6}, "b" => {"x" => 40, "y" => 60}}], j.call([{"a" => {"x" => 1, "y" => 2}, "b" => {"x" => 10, "y" => 20}}, {"a" => {"x" => 3, "y" => 4}, "b" => {"x" => 30, "y" => 40}}]), "library nested map_values reduce")
+
 # map hash transform
 j = Jrf.new(proc { map { |k, v| "#{k}=#{v}" } })
 assert_equal([["a=1", "b=2"]], j.call([{"a" => 1, "b" => 2}]), "library map hash transform")
@@ -960,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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jrf
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.12
 platform: ruby
 authors:
 - kazuho