jgrep 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f1b59d081b76f0692d89d7d99d40cb361215ed5
-  data.tar.gz: e173dbd8230dedcfb2a77c9bdb355d7293a67f66
+  metadata.gz: bc2ae50ca974a9033f6bca65254c009705305587
+  data.tar.gz: 36c22db07d3980bd372071c537bde74c846ccfed
 SHA512:
-  metadata.gz: bac482d335720345795310014895a0188b1458e7c87fd2ec062ca2cdf0a6aa5a1cecc1eded73680e4632635acb9e2eca5b75f71363e701be015b514eb20906eb
-  data.tar.gz: 8624259c860b573792437681645991f3fd86a9fdc27530cd838c5988a8d1573c033eba23c632872ab1779b0226bd3eec7caa47488a187a96de14fd09b26baaa2
+  metadata.gz: 85342e07b0e672f19cebda3b426271736b02097df611b98171f54d297e5f2d394c9a2b83fe3a42ce4936f281bdd26806ff89659a2bd52fc3ee54d05b2772b3cd
+  data.tar.gz: 86ac2ba2a35df8aa5a7884f3b223a1e82a2d4b2980b69e86b84cdfde19227a3fd541f522d427b63891f1f482ce5d4b47a689798123bdfb5e142f28fc2a437798

data/CHANGELOG.markdown

@@ -1,5 +1,10 @@
 # Changelog
 
+## 1.5.0
+* Dropped support for Ruby 1.8.3
+* Added support for modern Ruby versions (Tested up to 2.4.0)
+* Added utility method to validate expressions
+
 ## 1.4.1
 * Fix binary exit code to be 1 when no matches are found (Mickaël Canévet)
 

data/README.markdown

@@ -1,12 +1,12 @@
 JGrep is a command line tool and API for parsing JSON documents based on logical expressions.
 
-###Installation:###
+### Installation:
 
 jgrep is available as a gem:
 
     gem install jgrep
 
-###JGrep binary usage:###
+### JGrep binary usage:
 
     jgrep [expression] -i foo.json
 
@@ -14,7 +14,7 @@ or
 
     cat "foo.json" | jgrep [expression]
 
-###Flags:###
+### 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
@@ -26,7 +26,7 @@ or
         --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###
+### Expressions:
 
 JGrep uses the following logical symbols to define expressions.
 
@@ -62,7 +62,7 @@ JGrep uses the following logical symbols to define expressions.
 
         Performs the operations inside the perentheses first.
 
-###Statements:###
+### Statements:
 
 A statement is defined as some value in a json document compared to another value.
 Available comparison operators are '=', '<', '>', '<=', '>='
@@ -73,7 +73,7 @@ Examples:
     foo.bar>0
     foo.bar<=1.3
 
-###Complex expressions:###
+### Complex expressions:
 
 Given a json document, {"foo":1, "bar":null}, the following are examples of valid expressions
 
@@ -95,12 +95,12 @@ Examples:
 
 ... returns true
 
-###CLI missing an expression###
+### 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:###
+### 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.
@@ -152,7 +152,7 @@ will return
 
 **Note**: In document comparison cannot be nested.
 
-###The -s flag###
+### The -s flag:
 
 The s flag simplifies the output returned by JGrep. Given a JSON document
 
@@ -167,7 +167,7 @@ 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) 
+**Note**: Separate fields by a space and enclose all fields in quotes (see example below)
 
 Given:
 
@@ -190,7 +190,7 @@ will output
       }
     ]
 
-###The --start flag###
+### 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.
@@ -230,7 +230,7 @@ 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:###
+### JGrep Gem usage:
 
     require 'jgrep'
 
@@ -242,3 +242,4 @@ as usual, but the output immediately printed.
     sflags = "foo"
 
     JGrep::jgrep(json, expression, sflags)
+

data/Rakefile

@@ -2,4 +2,9 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+desc "Run rubycop style checks"
+task :rubocop do
+  sh("rubocop -f progress -f offenses lib spec bin")
+end
+
+task :default => [:rubocop, :spec]

data/bin/jgrep

@@ -1,153 +1,139 @@
 #!/usr/bin/env ruby
 
-require 'jgrep'
-require 'optparse'
+require "jgrep"
+require "optparse"
 
-@options = {:flat => false, :start => nil, :field => [], :slice => nil}
+@options = {flat: false, start: nil, field: [], slice: nil}
 
 def print_json(result)
-    unless @options[:flat]
-        result = result.first if @options[:stream]
-        puts(JSON.pretty_generate(result))
-    else
-        puts(result.first.to_json)
-    end
+  if @options[:flat]
+    puts(result.first.to_json)
+  else
+    result = result.first if @options[:stream]
+    puts(JSON.pretty_generate(result))
+  end
 end
 
 def do_grep(json, expression)
-    if @options[:field].empty?
-        result = JGrep::jgrep((json), expression, nil, @options[:start])
-        result = result.slice(@options[:slice]) if @options[:slice]
-        exit 1 if result == []
-        unless @options[:quiet] == true
-            print_json(result)
-        end
+  if @options[:field].empty?
+    result = JGrep.jgrep(json, expression, nil, @options[:start])
+    result = result.slice(@options[:slice]) if @options[:slice]
+
+    exit 1 if result == []
+
+    print_json(result) unless @options[:quiet] == true
+  elsif @options[:field].size > 1
+    JGrep.validate_filters(@options[:field])
+    result = JGrep.jgrep(json, expression, @options[:field], @options[:start])
+    result = result.slice(@options[:slice]) if @options[:slice]
+
+    exit 1 if result == []
+
+    print_json(result) unless @options[:quiet] == true
+
+  else
+    JGrep.validate_filters(@options[:field][0])
+    result = JGrep.jgrep(json, expression, @options[:field][0], @options[:start])
+    result = result.slice(@options[:slice]) if @options[:slice]
+    exit 1 if result == []
+    if result.is_a?(Array) && !(result.first.is_a?(Hash) || result.flatten.first.is_a?(Hash))
+      unless @options[:quiet] == true
+        result.map {|x| puts x unless x.nil?}
+      end
     else
-        if @options[:field].size > 1
-            JGrep::validate_filters(@options[:field])
-            result = JGrep::jgrep((json), expression, @options[:field], @options[:start])
-            result = result.slice(@options[:slice]) if @options[:slice]
-            exit 1 if result == []
-            unless @options[:quiet] == true
-                print_json(result)
-            end
-
-        else
-            JGrep::validate_filters(@options[:field][0])
-            result = JGrep::jgrep((json), expression, @options[:field][0], @options[:start])
-            result = result.slice(@options[:slice]) if @options[:slice]
-            exit 1 if result == []
-            if result.is_a?(Array) && !(result.first.is_a?(Hash) || result.flatten.first.is_a?(Hash))
-                unless @options[:quiet] == true
-                    result.map{|x| puts x unless x.nil?}
-                end
-            else
-                unless @options[:quiet] == true
-                    print_json(result)
-                end
-            end
-        end
+      print_json(result) unless @options[:quiet] == true
     end
+  end
 end
 
 begin
-    OptionParser.new do |opts|
-        opts.banner = "Usage: jgrep [options] \"expression\""
-        opts.on("-s", "--simple [FIELDS]", "Display only one or more fields from each of the resulting json documents") do |field|
-            unless field.nil?
-                @options[:field].concat(field.split(" "))
-            else
-                raise "-s flag requires a field value"
-            end
-        end
-
-        opts.on("-c", "--compact", "Display non pretty json") do
-            @options[:flat] = true
-        end
-
-        opts.on("-n", "--stream", "Display continuous output from continuous input") do
-            @options[:stream] = true
-        end
-
-        opts.on("-f", "--flatten", "Makes output as flat as possible") do
-            JGrep::flatten_on
-        end
-
-        opts.on("-i", "--input [FILENAME]", "Specify input file to parse") do |filename|
-            @options[:file] = filename
-        end
-
-        opts.on("-q", "--quiet", "Quiet; don't write to stdout.  Exit with zero status if match found.") do
-            @options[:quiet] = true
-        end
-
-        opts.on("-v", "--verbose", "Verbose output") do
-            JGrep::verbose_on
-        end
-
-        opts.on("--start [FIELD]", "Where in the data to start from") do |field|
-            @options[:start] = field
-        end
-
-        opts.on("--slice [RANGE]", "A range of the form 'n' or 'n..m', indicating which documents to extract from the final output") do |field|
-            range_nums = field.split('..').map{ |x| x.to_i }
-            @options[:slice] = range_nums.length == 1 ? range_nums[0] : Range.new(*range_nums)
-        end
-    end.parse!
-rescue OptionParser::InvalidOption => e
-    puts e.to_s.capitalize
-    exit 1
+  OptionParser.new do |opts|
+    opts.banner = "Usage: jgrep [options] \"expression\""
+    opts.on("-s", "--simple [FIELDS]", "Display only one or more fields from each of the resulting json documents") do |field|
+      raise "-s flag requires a field value" if field.nil?
+
+      @options[:field].concat(field.split(" "))
+    end
+
+    opts.on("-c", "--compact", "Display non pretty json") do
+      @options[:flat] = true
+    end
 
-rescue Exception => e
-    puts e
-    exit 1
+    opts.on("-n", "--stream", "Display continuous output from continuous input") do
+      @options[:stream] = true
+    end
+
+    opts.on("-f", "--flatten", "Makes output as flat as possible") do
+      JGrep.flatten_on
+    end
+
+    opts.on("-i", "--input [FILENAME]", "Specify input file to parse") do |filename|
+      @options[:file] = filename
+    end
+
+    opts.on("-q", "--quiet", "Quiet; don't write to stdout.  Exit with zero status if match found.") do
+      @options[:quiet] = true
+    end
+
+    opts.on("-v", "--verbose", "Verbose output") do
+      JGrep.verbose_on
+    end
+
+    opts.on("--start [FIELD]", "Where in the data to start from") do |field|
+      @options[:start] = field
+    end
+
+    opts.on("--slice [RANGE]", "A range of the form 'n' or 'n..m', indicating which documents to extract from the final output") do |field|
+      range_nums = field.split("..").map(&:to_i)
+      @options[:slice] = range_nums.length == 1 ? range_nums[0] : Range.new(*range_nums)
+    end
+  end.parse!
+rescue OptionParser::InvalidOption => e
+  puts e.to_s.capitalize
+  exit 1
+rescue Exception => e # rubocop:disable Lint/RescueException
+  puts e
+  exit 1
 end
 
 begin
-    expression = nil
-
-    #Identify the expression from command line arguments
-    ARGV.each do |argument|
-        if argument =~ /<|>|=|\+|-/
-            expression = argument
-            ARGV.delete(argument)
-        end
+  expression = nil
+
+  # Identify the expression from command line arguments
+  ARGV.each do |argument|
+    if argument =~ /<|>|=|\+|-/
+      expression = argument
+      ARGV.delete(argument)
     end
+  end
 
-    expression = "" if expression.nil?
+  expression = "" if expression.nil?
 
-    #Continuously gets if inputstream in constant
-    #Load json from standard input if tty is false
-    #else find and load file from command line arugments
+  # Continuously gets if inputstream in constant
+  # Load json from standard input if tty is false
+  # else find and load file from command line arugments
 
-    if @options[:stream]
-        unless STDIN.tty?
-            while json = gets
-                do_grep(json, expression)
-            end
-        else
-            raise "No json input specified"
-        end
-    else
-        if @options[:file]
-            json = File.read(@options[:file])
-            do_grep(json, expression)
-        elsif ! STDIN.tty?
-            json = STDIN.read
-            do_grep(json, expression)
-        else
-            raise "No json input specified"
-        end
-    end
+  if @options[:stream]
+    raise "No json input specified" if STDIN.tty?
 
-rescue Interrupt
-    STDERR.puts "Exiting..."
-    exit 1
-rescue Exception => e
-    if e.is_a?(SystemExit)
-        exit e.status
-    else
-        STDERR.puts "Error - #{e}"
-        exit 1
+    while json = gets
+      do_grep(json, expression)
     end
+  elsif @options[:file]
+    json = File.read(@options[:file])
+    do_grep(json, expression)
+  elsif !STDIN.tty?
+    json = STDIN.read
+    do_grep(json, expression)
+  else
+    raise "No json input specified"
+  end
+rescue Interrupt
+  STDERR.puts "Exiting..."
+  exit 1
+rescue SystemExit
+  exit e.status
+rescue Exception => e # rubocop:disable Lint/RescueException
+  STDERR.puts "Error - #{e}"
+  exit 1
 end

data/lib/jgrep.rb

@@ -1,446 +1,355 @@
-#! /usr/lib/env ruby
-
-require 'parser/parser.rb'
-require 'parser/scanner.rb'
-require 'rubygems'
-require 'json'
-#require 'yajl/json_gem'
+require "parser/parser.rb"
+require "parser/scanner.rb"
+require "rubygems"
+require "json"
 
 module JGrep
-    @verbose = false
-    @flatten = false
-
-    def self.verbose_on
-        @verbose = true
-    end
-
-    def self.flatten_on
-        @flatten = true
-    end
-
-    #Parse json and return documents that match the logical expression
-    #Filters define output by limiting it to only returning a the listed keys.
-    #Start allows you to move the pointer indicating where parsing starts.
-    #Default is the first key in the document heirarchy
-    def self.jgrep(json, expression, filters = nil, start = nil)
-        errors = ""
-        begin
-            JSON.create_id = nil
-            json = JSON.parse(json)
-            if json.is_a? Hash
-                json = [json]
-            end
-
-            json = filter_json(json, start).flatten if start
-
-            result = []
-            unless expression == ""
-                call_stack = Parser.new(expression).execution_stack
-
-                json.each do |document|
-                    begin
-                        if eval_statement(document, call_stack)
-                            result << document
-                        end
-                    rescue Exception => e
-                        if @verbose
-                            require 'pp'
-                            pp document
-                            STDERR.puts "Error - #{e} \n\n"
-                        else
-                            errors = "One or more the json documents could not be parsed. Run jgrep -v for to display documents"
-                        end
-                    end
-                end
+  @verbose = false
+  @flatten = false
+
+  def self.verbose_on
+    @verbose = true
+  end
+
+  def self.flatten_on
+    @flatten = true
+  end
+
+  # Parse json and return documents that match the logical expression
+  # Filters define output by limiting it to only returning a the listed keys.
+  # Start allows you to move the pointer indicating where parsing starts.
+  # Default is the first key in the document heirarchy
+  def self.jgrep(json, expression, filters = nil, start = nil)
+    errors = ""
+
+    begin
+      JSON.create_id = nil
+      json = JSON.parse(json)
+      json = [json] if json.is_a?(Hash)
+
+      json = filter_json(json, start).flatten if start
+
+      result = []
+
+      if expression == ""
+        result = json
+      else
+        call_stack = Parser.new(expression).execution_stack
+
+        json.each do |document|
+          begin
+            result << document if eval_statement(document, call_stack)
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            if @verbose
+              require "pp"
+              pp document
+              STDERR.puts "Error - #{e} \n\n"
             else
-                result = json
+              errors = "One or more the json documents could not be parsed. Run jgrep -v for to display documents"
             end
+          end
+        end
+      end
 
-            unless errors == ""
-                puts errors
-            end
+      puts errors unless errors == ""
 
-            unless filters
-                return result
-            else
-                filter_json(result, filters)
-            end
+      return result unless filters
 
-        rescue JSON::ParserError => e
-            STDERR.puts "Error. Invalid JSON given"
-        end
+      filter_json(result, filters)
+    rescue JSON::ParserError
+      STDERR.puts "Error. Invalid JSON given"
     end
-
-    #Convert a specific hash inside a JSON document to an array
-    #Mark is a string in the format foo.bar.baz that points to
-    #the array in the document.
-    def self.hash_to_array(documents, mark)
-
-        begin
-            documents = JSON.parse(documents)
-        rescue JSON::ParserError => e
-            STDERR.puts "Error. Invalid JSON given"
-            exit 1
+  end
+
+  # Validates an expression, true when no errors are found else a string representing the issues
+  def self.validate_expression(expression)
+    Parser.new(expression)
+    true
+  rescue
+    $!.message
+  end
+
+  # Strips filters from json documents and returns those values as a less bloated json document
+  def self.filter_json(documents, filters)
+    result = []
+
+    if filters.is_a? Array
+      documents.each do |doc|
+        tmp_json = {}
+
+        filters.each do |filter|
+          filtered_result = dig_path(doc, filter)
+          unless (filtered_result == doc) || filtered_result.nil?
+            tmp_json[filter] = filtered_result
+          end
         end
+        result << tmp_json
+      end
+    else
+      documents.each do |r|
+        filtered_result = dig_path(r, filters)
+
+        unless (filtered_result == r) || filtered_result.nil?
+          result << filtered_result
+        end
+      end
+    end
 
-        result = []
-
-        begin
-            for i in 0..(documents.size - 1) do
-                tmp = documents[i]
-                unless mark == ""
-                    mark.split(".").each_with_index do |m,i|
-                        tmp = tmp[m] unless i == mark.split(".").size - 1
-                    end
-                end
+    result.flatten if @flatten == true && result.size == 1
 
-                tmp[mark.split.last].each{|d| result << {"value" => d[1], "key" => d[0]}}
-                tmp[mark.split.last] = result
+    result
+  end
 
-            end
-        rescue Exception => e
-            STDERR.puts "Error. Invalid position specified in JSON document"
-            exit!
+  # Validates if filters do not match any of the parser's logical tokens
+  def self.validate_filters(filters)
+    if filters.is_a? Array
+      filters.each do |filter|
+        if filter =~ /=|<|>|^and$|^or$|^!$|^not$/
+          raise "Invalid field for -s filter : '#{filter}'"
         end
-
-        puts JSON.pretty_generate(documents)
-
+      end
+    elsif filters =~ /=|<|>|^and$|^or$|^!$|^not$/
+      raise "Invalid field for -s filter : '#{filters}'"
     end
 
-    #Convert a specific array inside a JSON document to a hash
-    #Mark is a string in the format foo.bar.baz that points to
-    #the hash in the document. Each element in the array will
-    #be turned into a hash in the format key => array[x]
-    def self.array_to_hash(documents, mark, key)
-
-        begin
-            documents = JSON.parse(documents)
-        rescue JSON::ParserError => e
-            STDERR.puts "Error. Invalid JSON given"
-            exit 1
+    nil
+  end
+
+  # Correctly format values so we can do the correct type of comparison
+  def self.format(kvalue, value)
+    if kvalue.to_s =~ /^\d+$/ && value.to_s =~ /^\d+$/
+      [Integer(kvalue), Integer(value)]
+    elsif kvalue.to_s =~ /^\d+.\d+$/ && value.to_s =~ /^\d+.\d+$/
+      [Float(kvalue), Float(value)]
+    else
+      [kvalue, value]
+    end
+  end
+
+  # Check if the json key that is defined by statement is defined in the json document
+  def self.present?(document, statement)
+    statement.split(".").each do |key|
+      if document.is_a? Hash
+        if document.value?(nil)
+          document.each do |k, _|
+            document[k] = "null" if document[k].nil?
+          end
         end
+      end
 
-        result = {}
+      if document.is_a? Array
+        rval = false
+        document.each do |doc|
+          rval ||= present?(doc, key)
+        end
+        return rval
+      end
 
-        begin
-            for i in 0..(documents.size - 1) do
-                tmp = documents[i]
-                unless mark == ""
-                    mark.split(".").each_with_index do |m,i|
-                        tmp = tmp[m] unless i == mark.split(".").size - 1
-                    end
-                end
+      document = document[key]
 
-                tmp[mark.split(".").last].each{|d| result[d[key]] = d}
-                tmp[mark.split(".").last] = result
+      return false if document.nil?
+    end
 
-            end
-        rescue Exception => e
-            STDERR.puts "Error. Invalid position specified in JSON document"
-            exit!
-        end
+    true
+  end
 
-        puts JSON.pretty_generate(documents)
+  # Check if key=value is present in document
+  def self.has_object?(document, statement)
+    key, value = statement.split(/<=|>=|=|<|>/)
 
+    if statement =~ /(<=|>=|<|>|=)/
+      op = $1
+    else
+      op = statement
     end
 
-    #Strips filters from json documents and returns those values as a less bloated json document
-    def self.filter_json(documents, filters)
-        result = []
+    tmp = dig_path(document, key)
 
-        if filters.is_a? Array
-            documents.each do |doc|
-                tmp_json = {}
-                filters.each do |filter|
-                    filtered_result = dig_path(doc, filter)
-                    unless (filtered_result == doc) || filtered_result.nil?
-                        tmp_json[filter] = filtered_result
-                    end
-                end
-                result << tmp_json
-            end
+    tmp = tmp.first if tmp.is_a?(Array) && tmp.size == 1
 
-            result = result.flatten if (result.size == 1 && @flatten == true)
-            return result
+    tmp, value = format(tmp, (value.gsub(/"|'/, "") unless value.nil?)) # rubocop:disable Style/FormatString
 
-        else
-            documents.each do |r|
-                filtered_result = dig_path(r, filters)
-                unless (filtered_result == r) || filtered_result.nil?
-                    result << filtered_result
-                end
-            end
+    # Deal with null comparison
+    return true if tmp.nil? && value == "null"
 
-            result = result.flatten if (result.size == 1 && @flatten == true)
-            return result
-        end
-    end
+    # Deal with booleans
+    return true if tmp == true && value == "true"
+    return true if tmp == false && value == "false"
 
-    #Validates if filters do not match any of the parser's logical tokens
-    def self.validate_filters(filters)
-        if filters.is_a? Array
-            filters.each do |filter|
-                if filter =~ /=|<|>|^and$|^or$|^!$|^not$/
-                    raise "Invalid field for -s filter : '#{filter}'"
-                end
-            end
-        else
-            if filters =~ /=|<|>|^and$|^or$|^!$|^not$/
-                raise "Invalid field for -s filter : '#{filters}'"
-            end
-        end
-        return
+    # Deal with regex matching
+    if !tmp.nil? && value =~ /^\/.*\/$/
+      tmp.match(Regexp.new(value.delete("/"))) ? (return true) : (return false)
     end
 
-    #Correctly format values so we can do the correct type of comparison
-    def self.format(kvalue, value)
-        if kvalue.to_s =~ /^\d+$/ && value.to_s =~ /^\d+$/
-            return Integer(kvalue), Integer(value)
-        elsif kvalue.to_s =~ /^\d+.\d+$/ && value.to_s =~ /^\d+.\d+$/
-            return Float(kvalue), Float(value)
-        else
-            return kvalue, value
-        end
+    # Deal with everything else
+    case op
+    when "="
+      return tmp == value
+    when "<="
+      return tmp <= value
+    when ">="
+      return tmp >= value
+    when ">"
+      return tmp > value
+    when "<"
+      return tmp < value
     end
+  end
 
+  # Check if key=value is present in a sub array
+  def self.is_object_in_array?(document, statement)
+    document.each do |item|
+      return true if has_object?(item, statement)
+    end
 
-    #Check if the json key that is defined by statement is defined in the json document
-    def self.present?(document, statement)
-        statement.split(".").each do |key|
-            if document.is_a? Hash
-                if document.has_value? nil
-                    document.each do |k, v|
-                        if document[k] == nil
-                            document[k] = "null"
-                        end
-                    end
-                end
-            end
-
-            if document.is_a? Array
-                rval = false
-                document.each do |doc|
-                    rval ||= present?(doc, key)
-                end
-                return rval
-            end
-
-            document = document[key]
-            if document.nil?
-                return false
-            end
-        end
-        return true
+    false
+  end
+
+  # Check if complex statement (defined as [key=value...]) is
+  # present over an array of key value pairs
+  def self.has_complex?(document, compound)
+    field = ""
+    tmp = document
+    result = []
+    fresult = []
+
+    compound.each do |token|
+      if token[0] == "statement"
+        field = token
+        break
+      end
     end
 
-    #Check if key=value is present in document
-    def self.has_object?(document, statement)
+    field = field[1].split(/=|<|>/).first
 
-        key,value = statement.split(/<=|>=|=|<|>/)
+    field.split(".").each_with_index do |item, _|
+      tmp = tmp[item]
 
-        if statement =~ /(<=|>=|<|>|=)/
-            op = $1
-        else
-            op = statement
-        end
+      return false if tmp.nil?
 
-        tmp = dig_path(document, key)
+      next unless tmp.is_a?(Array)
 
-        if tmp.is_a?(Array) and tmp.size == 1
-            tmp = tmp.first
-        end
-
-        tmp, value = format(tmp, (value.gsub(/"|'/, "") unless value.nil?))
+      tmp.each do |doc|
+        result = []
 
-        #Deal with null comparison
-        if tmp.nil? and value == "null"
-            return true
+        compound.each do |token|
+          case token[0]
+          when "and"
+            result << "&&"
+          when "or"
+            result << "||"
+          when /not|\!/
+            result << "!"
+          when "statement"
+            op = token[1].match(/.*<=|>=|=|<|>/)
+            left = token[1].split(op[0]).first.split(".").last
+            right = token[1].split(op[0]).last
+            new_statement = left + op[0] + right
+            result << has_object?(doc, new_statement)
+          end
         end
 
-        # Deal with booleans
-        if tmp == true and value == 'true'
-            return true
-        elsif tmp == false and value == 'false'
-            return true
-        end
+        fresult << eval(result.join(" ")) # rubocop:disable Security/Eval
+        (fresult << "||") unless doc == tmp.last
+      end
 
-        #Deal with regex matching
-        if ((value =~ /^\/.*\/$/) && tmp != nil)
-            (tmp.match(Regexp.new(value.gsub("/", "")))) ? (return true) : (return false)
-        end
-
-        #Deal with everything else
-        case op
-            when "="
-                (tmp == value) ? (return true) : (return false)
-            when "<="
-                (tmp <= value) ? (return true) : (return false)
-            when ">="
-                (tmp >= value) ? (return true) : (return false)
-            when ">"
-                (tmp > value) ? (return true) : (return false)
-            when "<"
-                (tmp < value) ? (return true) : (return false)
-        end
+      return eval(fresult.join(" ")) # rubocop:disable Security/Eval
     end
-
-    #Check if key=value is present in a sub array
-    def self.is_object_in_array?(document, statement)
-
-        document.each do |item|
-            if has_object?(item,statement)
-                return true
-           end
+  end
+
+  # Evaluates the call stack en returns true of selected document
+  # matches logical expression
+  def self.eval_statement(document, callstack)
+    result = []
+
+    callstack.each do |expression|
+      case expression.keys.first
+      when "statement"
+        if expression.values.first.is_a?(Array)
+          result << has_complex?(document, expression.values.first)
+        else
+          result << has_object?(document, expression.values.first)
         end
-
-        return false
+      when "+"
+        result << present?(document, expression.values.first)
+      when "-"
+        result << !present?(document, expression.values.first)
+      when "and"
+        result << "&&"
+      when "or"
+        result << "||"
+      when "("
+        result << "("
+      when ")"
+        result << ")"
+      when "not"
+        result << "!"
+      end
     end
 
-    #Check if complex statement (defined as [key=value...]) is
-    #present over an array of key value pairs
-    def self.has_complex?(document, compound)
-        field = ""
-        tmp = document
-        result = []
-        fresult = []
+    eval(result.join(" ")) # rubocop:disable Security/Eval
+  end
 
-        compound.each do |token|
-            if token[0] == "statement"
-                field = token
-                break
-            end
-        end
-        field = field[1].split(/=|<|>/).first
+  # Digs to a specific path in the json document and returns the value
+  def self.dig_path(json, path)
+    index = nil
+    path = path.gsub(/^\./, "")
 
-        field.split(".").each_with_index do |item, i|
-            tmp = tmp[item]
-            if tmp.nil?
-                return false
-            end
-            if tmp.is_a? Array
-                tmp.each do |doc|
-                    result = []
-                    compound.each do |token|
-                        case token[0]
-                            when "and"
-                                result << "&&"
-                            when "or"
-                                result << "||"
-                            when  /not|\!/
-                                result << "!"
-                            when "statement"
-                                op = token[1].match(/.*<=|>=|=|<|>/)
-                                left = token[1].split(op[0]).first.split(".").last
-                                right = token[1].split(op[0]).last
-                                new_statement = left + op[0] + right
-                                result << has_object?(doc, new_statement)
-                        end
-                    end
-                    fresult << eval(result.join(" "))
-                    (fresult << "||") unless doc == tmp.last
-                end
-                return eval(fresult.join(" "))
-            end
-        end
+    if path =~ /(.*)\[(.*)\]/
+      path = $1
+      index = $2
     end
 
-    #Evaluates the call stack en returns true of selected document
-    #matches logical expression
-    def self.eval_statement(document, callstack)
-        result = []
-        callstack.each do |expression|
-            case expression.keys.first
-            when "statement"
-                if  expression.values.first.is_a? Array
-                    result << has_complex?(document, expression.values.first)
-                else
-                    result << has_object?(document, expression.values.first)
-                end
-            when "+"
-                result << present?(document, expression.values.first)
-            when "-"
-                result << !(present?(document, expression.values.first))
-            when "and"
-                result << "&&"
-            when "or"
-                result << "||"
-            when "("
-                result << "("
-            when ")"
-                result << ")"
-            when "not"
-                result << "!"
-            end
-        end
+    return json if path == ""
 
-        return eval(result.join(" "))
+    if json.is_a? Hash
+      json.keys.each do |k|
+        if path.start_with?(k) && k.include?(".")
+          return dig_path(json[k], path.gsub(k, ""))
+        end
+      end
     end
 
-    #Digs to a specific path in the json document and returns the value
-    def self.dig_path(json, path)
-        index = nil
-        path = path.gsub(/^\./, "")
+    path_array = path.split(".")
 
-        if path =~ /(.*)\[(.*)\]/
-            path = $1
-            index = $2
-        end
+    if path_array.first == "*"
+      tmp = []
 
-        if path == ""
-            return json
-        end
+      json.each do |j|
+        tmp << dig_path(j[1], path_array.drop(1).join("."))
+      end
 
-        if json.is_a? Hash
-            json.keys.each do |k|
-                if path.start_with?(k) && k.include?('.')
-                    return dig_path(json[k], path.gsub(k, ""))
-                end
-            end
-        end
+      return tmp
+    end
 
-        path_array=path.split(".")
+    json = json[path_array.first] if json.is_a? Hash
 
-        if path_array.first == "*"
-            tmp = []
-            json.each do |j|
-                tmp << dig_path(j[1], path_array.drop(1).join("."))
-            end
-            return tmp
+    if json.is_a? Hash
+      return json if path == path_array.first
+      return dig_path(json, path.include?(".") ? path_array.drop(1).join(".") : path)
 
-        end
+    elsif json.is_a? Array
+      if path == path_array.first && (json.first.is_a?(Hash) && !json.first.keys.include?(path))
+        return json
+      end
 
-        json = json[path_array.first] if json.is_a? Hash
-
-        if json.is_a? Hash
-            if path == path_array.first
-                return json
-            else
-                return dig_path(json, (path.include?('.') ? path_array.drop(1).join(".") : path))
-            end
+      tmp = []
 
-        elsif json.is_a? Array
-            if path == path_array.first && (json.first.is_a?(Hash) && !(json.first.keys.include?(path)))
-                return json
-            else
-                tmp = []
-                json.each do |j|
-                    tmp_path = dig_path(j, (path.include?('.') ? path_array.drop(1).join(".") : path))
-                    unless tmp_path.nil?
-                        tmp << tmp_path
-                    end
-                end
-                unless tmp.empty?
-                    (index) ? (return tmp.flatten[index.to_i]) : (return tmp)
-                end
-            end
+      json.each do |j|
+        tmp_path = dig_path(j, (path.include?(".") ? path_array.drop(1).join(".") : path))
+        tmp << tmp_path unless tmp_path.nil?
+      end
 
-        elsif json.nil?
-            return nil
+      unless tmp.empty?
+        return index ? tmp.flatten[index.to_i] : tmp
+      end
 
-        else
-            return json
+    elsif json.nil?
+      return nil
 
-        end
+    else
+      return json
 
     end
+  end
 end