Project

jgrep

0.19
No release in over 3 years
Low commit activity in last 3 years
There's a lot of open issues
Compare a list of json documents to a simple logical language and returns matches as output
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
 Dependencies
 Project Readme

JGrep is a command line tool and API for parsing JSON documents based on logical expressions.

Installation:

jgrep is available as a gem:

gem install jgrep

JGrep binary usage:

jgrep [expression] -i foo.json

or

cat "foo.json" | jgrep [expression]

Flags:

-s, --simple [FIELDS]   : Greps the JSON and only returns the value of the field(s) specified
-c, --compat            : Returns the JSON in its non-pretty flat form
-n, --stream            : Specify continuous input
-f, --flatten           : Flatten the results as much as possible
-i, --input [FILENAME]  : Target JSON file to use as input
-q, --quiet             : Quiet; don't write to stdout.  Exit with zero status if match found.
-v, --verbose           : Verbose output that will list a document if it fails to parse
    --start FIELD       : Starts the grep at a specific key in the document
    --slice [RANGE]     : A range of the form 'n' or 'n..m', indicating which documents to extract from the final output

Expressions:

JGrep uses the following logical symbols to define expressions.

'and' :
    - [statement] and [statement]

    Evaluates to true if both statements are true

'or' :
    - [statement] or [statement]

    Evaluates true if either statement is true

'not' :
    - ! [statement]
    - not [statement]

    Inverts the value of statement

'+'
    - +[value]

    Returns true if value is present in the json document

'-'
    - -[value]

    Returns true if value is not present in the json doument

'(' and ')'

    - (expression1) and expression2

    Performs the operations inside the perentheses first.

Statements:

A statement is defined as some value in a json document compared to another value. Available comparison operators are '=', '<', '>', '<=', '>='

Examples:

foo.bar=1
foo.bar>0
foo.bar<=1.3

Complex expressions:

Given a json document, {"foo":1, "bar":null}, the following are examples of valid expressions

Examples:

+foo

... returns true

-bar

... returns false

+foo and !(foo=2)

... returns true

!(foo>=2 and bar=null) or !(bar=null)

... returns true

CLI missing an expression:

If JGrep is executed without a set expression, it will return an unmodified JSON document. The -s flag can still be applied to the result.

In document comparison:

If a document contains an array, the '[' and ']' operators can be used to define a comparison where statements are checked for truth on a per element basis which will then be combined.

Example:

[foo.bar1=1 and foo.bar2=2]

on

[
  {
    "foo":  [
      {
        "bar1":1
      },
      {
        "bar2":2
      }
    ]
  },
  {
    "foo":  [
      {
        "bar1":0
      },
      {
        "bar2":0
      }
    ]
  }
]

will return

[
  {
    "foo": [
      {
        "bar1": 1
      },
      {
        "bar2": 2
      }
    ]
  }
]

Note: In document comparison cannot be nested.

The -s flag:

The s flag simplifies the output returned by JGrep. Given a JSON document

[{"a":1, "b":2, "c":3}, {"a":3, "b":2, "c":1}]

a JGrep invocation like

cat my.json | jgrep "a=1" -s b

will output

1

The s flag can also be used with multiple field, which will return JSON as output which only contain the specified fields. Note: Separate fields by a space and enclose all fields in quotes (see example below)

Given:

[{"a":1, "b":2, "c":3}, {"a":3, "b":2, "c":1}]

a JGrep invocation like

cat my.json | jgrep "a>0" -s "a c"

will output

[
  {
    "a" : 1,
    "c" : 3
  },
  {
    "a" : 3,
    "c" : 1
  }
]

The --start flag:

Some documents do not comply to our expected format, they might have an array embedded deep in a field. The --start flag lets you pick a starting point for the grep.

An example document can be seen here:

{"results": [
              {"name":"Jack", "surname":"Smith"},
              {"name":"Jill", "surname":"Jones"}
            ]
}

This document does not comply to our standard but does contain data that can be searched - the results field. We can use the --start flat to tell jgrep to start looking for data in that field:

$ cat my.json | jgrep --start results name=Jack -s surname
Smith

The --slice flag

Allows the user to provide an int or range to slice an array of results with, in particular so a single element can be extracted, e.g.

$ echo '[{"foo": {"bar": "baz"}}, {"foo": {"bar":"baz"}}]' |
    jgrep "foo.bar=baz" --slice 0
{
  "foo": {
    "bar": "baz"
  }
}

The --stream flag

With the --stream or -n flag, jgrep will process multiple JSON inputs (newline separated) until standard input is closed. Each JSON input will be processed as usual, but the output immediately printed.

JGrep Gem usage:

require 'jgrep'

json = File.read("yourfile.json")
expression = "foo=1 or bar=1"

JGrep::jgrep(json, expression)

sflags = "foo"

JGrep::jgrep(json, expression, sflags)