jrf 0.1.12 → 0.1.13

data/test/library_api_test.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class LibraryApiTest < JrfTestCase
+  def test_basic_pipeline_api
+    j = Jrf.new(proc { _ })
+    assert_equal([{"a" => 1}, {"a" => 2}], j.call([{"a" => 1}, {"a" => 2}]), "library passthrough")
+
+    j = Jrf.new(proc { _["a"] })
+    assert_equal([1, 2], j.call([{"a" => 1}, {"a" => 2}]), "library extract")
+
+    j = Jrf.new(
+      proc { select(_["a"] > 1) },
+      proc { _["a"] }
+    )
+    assert_equal([2, 3], j.call([{"a" => 1}, {"a" => 2}, {"a" => 3}]), "library select + extract")
+
+    j = Jrf.new(proc { sum(_["a"]) })
+    assert_equal([6], j.call([{"a" => 1}, {"a" => 2}, {"a" => 3}]), "library sum")
+
+    j = Jrf.new(proc { sum(2 * _["a"]) })
+    assert_equal([12], j.call([{"a" => 1}, {"a" => 2}, {"a" => 3}]), "library sum literal on left")
+
+    j = Jrf.new(proc { {total: sum(_["a"]), n: count()} })
+    assert_equal([{total: 6, n: 3}], j.call([{"a" => 1}, {"a" => 2}, {"a" => 3}]), "library structured reducers")
+  end
+
+  def test_map_and_map_values_api
+    j = Jrf.new(proc { map { |x| x + 1 } })
+    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")
+
+    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")
+
+    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")
+
+    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")
+
+    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")
+
+    j = Jrf.new(proc { map { |pair| pair } })
+    assert_equal([[["a", 1], ["b", 2]]], j.call([{"a" => 1, "b" => 2}]), "library map hash single block arg")
+
+    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")
+  end
+
+  def test_apply_and_group_by_api
+    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")
+
+    j = Jrf.new(proc { apply { |x| x["foo"] } })
+    assert_equal([[1, 2]], j.call([[{"foo" => 1}, {"foo" => 2}]]), "library apply passthrough")
+
+    j = Jrf.new(proc { apply { |x| percentile(x, 0.5) } })
+    assert_equal([20], j.call([[10, 20, 30]]), "library apply percentile")
+
+    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")
+
+    j = Jrf.new(proc { map(_["items"]) { |x| x * 2 } })
+    assert_equal([[2, 4, 6]], j.call([{"items" => [1, 2, 3]}]), "library map 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")
+
+    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")
+  end
+
+  def test_percentile_and_control_flow_api
+    j = Jrf.new(proc { percentile(_["a"], _["p"]) })
+    assert_equal([2], j.call([{"a" => 1, "p" => 0.5}, {"a" => 2, "p" => [0.5, 1.0]}, {"a" => 3, "p" => [0.5, 1.0]}]), "library percentile configuration fixed by first row")
+
+    counting_percentiles = Class.new do
+      include Enumerable
+
+      attr_reader :each_calls
+
+      def initialize(values)
+        @values = values
+        @each_calls = 0
+      end
+
+      def each(&block)
+        @each_calls += 1
+        @values.each(&block)
+      end
+    end.new([0.25, 0.5, 1.0])
+
+    j = Jrf.new(proc { percentile(_["a"], counting_percentiles) })
+    assert_equal([[1, 2, 3]], j.call([{"a" => 1}, {"a" => 2}, {"a" => 3}]), "library percentile enumerable values")
+    assert_equal(1, counting_percentiles.each_calls, "library percentile materializes enumerable once")
+
+    j = Jrf.new(
+      proc { sum(_["a"]) },
+      proc { _ + 1 }
+    )
+    assert_equal([7], j.call([{"a" => 1}, {"a" => 2}, {"a" => 3}]), "library reducer then passthrough")
+
+    threshold = 2
+    j = Jrf.new(proc { select(_["a"] > threshold) })
+    assert_equal([{"a" => 3}], j.call([{"a" => 1}, {"a" => 2}, {"a" => 3}]), "library closure")
+
+    j = Jrf.new(proc { sum(_) })
+    assert_equal([], j.call([]), "library empty input")
+  end
+
+  def test_stage_reduce_control_tokens
+    ctx = Jrf::RowContext.new
+    stage = Jrf::Stage.new(ctx, proc { })
+    first_token = stage.step_reduce(1, initial: 0) { |acc, v| acc + v }
+    assert_equal(0, first_token.index, "step_reduce returns token while classifying reducer stage")
+    stage.instance_variable_set(:@mode, :reducer)
+    stage.instance_variable_set(:@cursor, 0)
+    second_token = stage.step_reduce(2, initial: 0) { |acc, v| acc + v }
+    assert_same(Jrf::Control::DROPPED, second_token, "expected DROPPED for established reducer slot")
+  end
+end

data/test/readme_examples_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class ReadmeExamplesTest < JrfTestCase
+  def test_built_in_function_examples
+    readme_examples = extract_readme_examples("./README.md", section: "BUILT-IN FUNCTIONS")
+    refute_empty(readme_examples, "expected README built-in examples")
+
+    readme_examples.each do |example|
+      stdout, stderr, status = run_jrf(example[:expr], example[:input])
+      assert_success(status, stderr, "README example #{example[:expr]}")
+      assert_equal(example[:output], lines(stdout), "README example output #{example[:expr]}")
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+begin
+  require "bundler/setup"
+rescue LoadError
+  # Allow running tests in plain Ruby environments with globally installed gems.
+end
+
+require "json"
+require "minitest/autorun"
+require "open3"
+require "stringio"
+require "tmpdir"
+require "zlib"
+require_relative "../lib/jrf"
+require_relative "../lib/jrf/cli/runner"
+
+class RecordingRunner < Jrf::CLI::Runner
+  attr_reader :writes
+
+  def initialize(**kwargs)
+    super
+    @writes = []
+  end
+
+  private
+
+  def write_output(str)
+    return if str.empty?
+
+    @writes << str
+  end
+end
+
+class JrfTestCase < Minitest::Test
+  def setup
+    File.chmod(0o755, "./exe/jrf")
+  end
+
+  def run_jrf(expr, input, *opts)
+    Open3.capture3("./exe/jrf", *opts, expr, stdin_data: input)
+  end
+
+  def assert_success(status, stderr, msg = nil)
+    return if status.success?
+
+    flunk("expected success#{msg ? " (#{msg})" : ""}, got failure\nstderr: #{stderr}")
+  end
+
+  def assert_failure(status, msg = nil)
+    return unless status.success?
+
+    flunk("expected failure#{msg ? " (#{msg})" : ""}, got success")
+  end
+
+  def assert_float_close(expected, actual, epsilon = 1e-9, msg = nil)
+    assert_in_delta(expected, actual, epsilon, msg)
+  end
+
+  def lines(str)
+    str.lines.map(&:strip).reject(&:empty?)
+  end
+
+  def json_stream_to_ndjson(text)
+    JSON.parse("[#{text}]").map { |value| "#{JSON.generate(value)}\n" }.join
+  end
+
+  def extract_readme_examples(path, section:)
+    content = File.read(path)
+    section_match = content.match(/^## #{Regexp.escape(section)}\n(.*?)(?=^## |\z)/m)
+    raise "section not found: #{section}" unless section_match
+
+    examples = []
+    section_text = section_match[1]
+    section_text.scan(/```sh\n(.*?)```/m) do |block_match|
+      block = block_match.first
+      lines = block.lines.map(&:chomp)
+      index = 0
+      while index < lines.length
+        line = lines[index]
+        if (command_match = line.match(/\Ajrf '(.*)'\z/))
+          comment = lines[index + 1]
+          if comment && (example_match = comment.match(/\A# (.+) → (.+)\z/))
+            examples << {
+              expr: command_match[1],
+              input: json_stream_to_ndjson(example_match[1]),
+              output: lines(json_stream_to_ndjson(example_match[2]))
+            }
+          end
+        end
+        index += 1
+      end
+    end
+    examples
+  end
+end
+
+class ChunkedSource
+  def initialize(str, chunk_size: 5)
+    @str = str
+    @chunk_size = chunk_size
+    @offset = 0
+  end
+
+  def read(length = nil, outbuf = nil)
+    raise "expected chunked reads" if length.nil?
+
+    chunk = @str.byteslice(@offset, [length, @chunk_size].min)
+    return nil unless chunk
+
+    @offset += chunk.bytesize
+    if outbuf
+      outbuf.replace(chunk)
+    else
+      chunk
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jrf
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - kazuho
@@ -23,6 +23,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.16'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
 description: jrf is a JSON filter with the power and speed of Ruby. It lets you write
   transforms as Ruby expressions, so you can use arbitrary Ruby logic. It supports
   extraction, filtering, flattening, sorting, and aggregation in stage pipelines.
@@ -47,7 +75,10 @@ files:
 - lib/jrf/row_context.rb
 - lib/jrf/stage.rb
 - lib/jrf/version.rb
-- test/jrf_test.rb
+- test/cli_runner_test.rb
+- test/library_api_test.rb
+- test/readme_examples_test.rb
+- test/test_helper.rb
 licenses:
 - MIT
 metadata: {}