view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

1.40  2025-11-08
    - Release jq-compatible ascii_downcase filter along with docs and tests.

1.39  2025-11-08
    - Add jq-compatible --arg option to the CLI and wire variables into the engine.
    - Allow passing initial variables when constructing JQ::Lite instances.
    - Document the new option and add regression tests for variable access.

1.38  2025-11-08
    - Release jq-compatible @json formatter support with documentation and tests.

1.37  2025-11-02
    - Release parenthesized pipeline evaluation improvements in expressions.

1.36  2025-11-02
    - Release jq-compatible @uri formatter and percent-encoding helper.
    - Declare Encode dependency and document formatter usage.

1.35  2025-11-01
    - Release base64 formatter support and dependency metadata updates.

1.34  2025-11-01
    - Publish homepage metadata updates for CPAN distribution listings.

1.33  2025-11-01
    - Skip YAML-related test on Perl 5.20–5.26 due to known incompatibility issues.
    - Updated test comments to English for consistency and clarity.

1.30  2025-10-25
  [Feature]
  - Add a jq-compatible @tsv formatter for tab-separated output with
    proper escaping of arrays and scalar values.

  [Release]
  - Bump version to 1.30.

1.29  2025-10-25
  [Feature]
  - Add jq-compatible comma sequence handling so each branch runs against the
    same input value and streams its results in order.

  [Tests]
  - Expand comma regression coverage to exercise chaining, optional access,
    array/object constructors, and syntax errors.

  [Release]
  - Bump version to 1.29.

1.28  2025-10-25
  [Feature]
  - Add a jq-compatible @csv filter for formatting scalars and arrays as
    CSV output.

1.27  2025-10-24
  [Release]
  - Bump version to 1.27 to publish the select() predicate evaluation fixes.

1.26  2025-10-24
  [Behavior]
  - Run select() predicates as streaming filters so inputs pass once for each
    truthy predicate result while preserving compatibility with comparison
    expressions.

1.25  2025-10-23
  [CLI]
  - Fix YAML input handling in jq-lite: allow scalar (non-ref) results to be
    encoded without warnings or failure by adding `allow_nonref` to the
    JSON::PP encoder in `print_results`. This resolves failures in
    t/yaml_cli.t:
      * YAML files auto-detected by extension now work as expected.
      * No warnings are emitted when parsing YAML (file or STDIN with --yaml).
      * Process exits successfully (status 0) on valid YAML input.
    (PR: GH#XX)

  [Behavior]
  - Output behavior for JSON inputs is unchanged; raw/compact/color options
    continue to work as before. YAML input is first converted to JSON and
    scalar top-level values are now treated correctly.

  [Internals]
  - Minimal code change: `JSON::PP->new->utf8->allow_nonref->canonical`
    in `print_results`.

1.24  2025-10-22
    [Tests]
    - Rewrite t/yaml_cli.t to remove dependency on YAML::XS.
      The test now parses YAML via core CPAN::Meta::YAML and converts
      it to JSON with core JSON::PP before invoking jq-lite.
      This makes the test suite pass on Perl 5.24 and 5.26 where
      YAML::XS may be unavailable and JSON::PP requires hash/array refs.
    - Stop asserting "YAML files are auto-detected by extension" and
      the --yaml STDIN path in this test; those behaviors are now
      independent of YAML::XS and no longer required for this file.
      (Runtime autodetection/--yaml can be covered by a separate,
      optional test when YAML::XS is present.)
    - Add small helpers and stricter assertions; ensure no spurious
      warnings are emitted when feeding JSON to jq-lite.

1.23  2025-10-21
    - Allowed the CLI’s JSON encoder to handle scalar values when printing results,
      eliminating YAML processing warnings on older Perl versions.

1.22  2025-10-20
    [Fixes]
    - Ensure nested filter helpers and the CLI YAML decoder encode scalars
      with `allow_nonref` so Perl 5.20 no longer dies on scalar documents.

1.21  2025-10-20
    [Fixes]
    - Allow `tojson` to encode scalar values by configuring JSON::PP with
      `allow_nonref`, restoring compatibility with Perl 5.22.

1.20  2025-10-19
    [Feature]
    - Introduce a dedicated arithmetic expression engine with numeric operators,
      precedence-aware parsing, and builtin math helpers.

    [Maintenance]
    - Ensure expression evaluation defers to existing filter handlers for
      non-math builtins so prior queries remain compatible.

Changes  view on Meta::CPAN

      explicit key/value pairs so map projections emit the expected hashes.
    - Ensure `map(...)` evaluates its filter against each array element,
      allowing comparisons like `(.age >= 20)` to yield booleans instead of
      null.

    [Tests]
    - Extend the map regression coverage to lock in shorthand object
      projections and boolean evaluation on each element.

1.13   2025-10-18
    [Feature]
    - Promote the release to 1.13 to ship jq-style object constructors so
      filters like `{ "name": .name }` emit hashes for each pipeline item.

    [Tests]
    - Include regression coverage for object constructor queries to lock in the
      new behavior.

1.12   2025-10-18
    [Feature]
    - Added jq-compatible array constructors so filters like `[.name, .age]`
      emit collected values for each input.

    [Tests]
    - Added regression coverage for array construction, including empty
      constructors and multi-value element expressions.

1.11   2025-10-18
    [Feature]
    - Added jq-compatible `--from-file` (`-f`) option so filters can be read
      from standalone jq scripts instead of the command line.

    [Tests]
    - Added CLI regression coverage ensuring queries loaded from files execute
      successfully and honor `--null-input` constraints.

    [Docs]
    - Documented the new `--from-file` flag across README and CLI usage text.

1.10   2025-10-18
    [Feature]
    - Added jq-style `if ... then ... elif ... else ... end` conditional
      expressions so queries can branch using familiar jq syntax, including
      cascading elif clauses and optional fallbacks.

    [Tests]
    - Added regression coverage for if/elif/else handling, including nested
      branches and expressions without an else clause.

    [Docs]
    - Documented conditional expressions across README, module POD, and the CLI
      help output.

1.09   2025-10-18
    - Promote the release version to 1.09 after adding jq-compatible
      foreach folding and test() helper support.

1.08   2025-10-18
    [Feature]
    - Added jq-compatible `foreach expr as $var (init; update [; extract])`
      folding with optional emitters so streaming reductions mirror jq.
    - Added jq-compatible `--slurp` (`-s`) option to wrap every JSON document
      from the input stream in a single array before executing filters.
    - Added jq's `test(pattern[, flags])` helper for regex matching with
      optional `imxs` modifiers.

    [Tests]
    - Added regression coverage ensuring foreach accumulates values and
      supports extract expressions referencing the iteration variable.
    - Added tests covering regex matches, flag handling, and array mapping via
      the new test() helper.

    [Docs]
    - Documented foreach across README, module POD, and CLI helper listings.
    - Documented test() in README, POD, and CLI help output.

1.06   2025-10-18
    - Added jq-compatible `--compact-output` (`-c`) flag to emit single-line
      JSON results from the jq-lite CLI.

1.05   2025-10-18
    - Added jq-style reduce syntax (`reduce expr as $var (init; update)`) with
      lexical variable bindings and `. +` arithmetic support.

1.04   2025-10-18
    [Features]
    - Added jq-compatible --null-input (-n) option to jq-lite so filters can
      run against null without providing input data.
    - Implemented jq's setpath(path; value) helper to create/update nested
      structures using literal paths or filter-generated path arrays.

    [Refactor]
    - Refactored JQ::Lite to delegate query parsing and filter execution to
      dedicated modules, keeping only orchestration logic in the main package.
    - Introduced JQ::Lite::Parser to normalize query strings before execution,
      handling trimming and shorthand conversions such as `.[]` into flatten
      semantics.
    - Centralized jq-style filter implementations in JQ::Lite::Filters, wiring
      each command to shared utility routines and standardizing result handling.
    - Moved shared helper functions into JQ::Lite::Util, consolidating common
      operations like assignments, traversal, and numeric utilities.

    [Maintenance]
    - Improved internal structure for clarity, maintainability, and easier
      extension of jq-compatible features in future releases.
    - No user-facing behavior changes; this refactor is fully backward
      compatible.

1.02   2025-10-16
    [Maintenance]
    - Promote the release version to 1.02 to ensure Perl's version parsing
      keeps this release newer than the historical 0.99.
    [Feature]
    - Added fromjson() helper to decode JSON text back into native data
      structures, mirroring jq's behaviour and complementing tojson().
    - Implemented jq's `//` alternative operator so pipelines can fall back to
      secondary expressions when the primary value is null or missing.
    [Tests]
    - Added regression coverage asserting fromjson() handles objects, arrays,
      invalid JSON text, and null propagation.
    - Added coalesce-focused regression tests covering literals, booleans, and