jgrep 1.3.3 → 1.4.0

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/jgrep

@@ -3,17 +3,67 @@
 require 'jgrep'
 require 'optparse'
 
-options = {:flat => false, :start => nil, :field => []}
+@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
+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]
+        unless result == [] or @options[:quiet] == true
+            print_json(result)
+        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]
+            unless result == [] or @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]
+            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
+    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|
-            options[:field].concat(field.split(" "))
+            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
+            @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
@@ -21,11 +71,11 @@ begin
         end
 
         opts.on("-i", "--input [FILENAME]", "Specify input file to parse") do |filename|
-            options[:file] = 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
+            @options[:quiet] = true
         end
 
         opts.on("-v", "--verbose", "Verbose output") do
@@ -33,12 +83,21 @@ begin
         end
 
         opts.on("--start [FIELD]", "Where in the data to start from") do |field|
-            options[:start] = 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
+
+rescue Exception => e
+    puts e
+    exit 1
 end
 
 begin
@@ -54,49 +113,33 @@ begin
 
     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
-    unless STDIN.tty?
-        json = STDIN.read
-    else
-        if options[:file]
-            json = File.read(options[:file])
+
+    if @options[:stream]
+        unless STDIN.tty?
+            while json = gets
+                do_grep(json, expression)
+            end
         else
             raise "No json input specified"
         end
-    end
-
-    if options[:field].empty?
-        result = JGrep::jgrep((json), expression, nil, options[:start])
-        unless options[:quiet] == true
-            (options[:flat] == false) ? puts(JSON.pretty_generate(result)) : puts(result.to_json)
-        end
     else
-        if options[:field].size > 1
-            JGrep::validate_filters(options[:field])
-            result = JGrep::jgrep((json), expression, options[:field], options[:start])
-            unless result == [] or options[:quiet] == true
-                puts(JSON.pretty_generate(result))
-            end
-
+        if @options[:file]
+            json = File.read(@options[:file])
+            do_grep(json, expression)
+        elsif ! STDIN.tty?
+            json = STDIN.read
+            do_grep(json, expression)
         else
-            JGrep::validate_filters(options[:field][0])
-            result = JGrep::jgrep((json), expression, options[:field][0], options[:start])
-            unless 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
-                    puts(JSON.pretty_generate(result))
-                end
-            end
-            unless result.length > 0
-                exit 1
-            end
+            raise "No json input specified"
         end
     end
 
+rescue Interrupt
+    STDERR.puts "Exiting..."
+    exit 1
 rescue Exception => e
     if e.is_a?(SystemExit)
         exit e.status

data/lib/jgrep.rb

@@ -257,6 +257,13 @@ module JGrep
             return true
         end
 
+        # Deal with booleans
+        if tmp == true and value == 'true'
+            return true
+        elsif tmp == false and value == 'false'
+            return true
+        end
+
         #Deal with regex matching
         if ((value =~ /^\/.*\/$/) && tmp != nil)
             (tmp.match(Regexp.new(value.gsub("/", "")))) ? (return true) : (return false)
@@ -303,7 +310,7 @@ module JGrep
                 break
             end
         end
-        field = field[1].first.split(/=|<|>/).first
+        field = field[1].split(/=|<|>/).first
 
         field.split(".").each_with_index do |item, i|
             tmp = tmp[item]
@@ -385,7 +392,7 @@ module JGrep
 
         if json.is_a? Hash
             json.keys.each do |k|
-                if path.match(/^#{k}/) && k.match(/\./)
+                if path.start_with?(k) && k.include?('.')
                     return dig_path(json[k], path.gsub(k, ""))
                 end
             end
@@ -408,7 +415,7 @@ module JGrep
             if path == path_array.first
                 return json
             else
-                return dig_path(json, (path.match(/\./) ? path_array.drop(1).join(".") : path))
+                return dig_path(json, (path.include?('.') ? path_array.drop(1).join(".") : path))
             end
 
         elsif json.is_a? Array
@@ -417,7 +424,7 @@ module JGrep
             else
                 tmp = []
                 json.each do |j|
-                    tmp_path = dig_path(j, (path.match(/\./) ? path_array.drop(1).join(".") : path))
+                    tmp_path = dig_path(j, (path.include?('.') ? path_array.drop(1).join(".") : path))
                     unless tmp_path.nil?
                         tmp << tmp_path
                     end

data/lib/parser/scanner.rb

@@ -14,7 +14,7 @@ module JGrep
             end
 
             begin
-                case @arguments.split("")[@token_index]
+                case chr(@arguments[@token_index])
                     when "["
                         return "statement", gen_substatement
 
@@ -28,7 +28,7 @@ module JGrep
                         return ")", ")"
 
                     when "n"
-                        if (@arguments.split("")[@token_index + 1] == "o") && (@arguments.split("")[@token_index + 2] == "t") && ((@arguments.split("")[@token_index + 3] == " ") || (@arguments.split("")[@token_index + 3] == "("))
+                        if (chr(@arguments[@token_index + 1]) == "o") && (chr(@arguments[@token_index + 2]) == "t") && ((chr(@arguments[@token_index + 3]) == " ") || (chr(@arguments[@token_index + 3]) == "("))
                             @token_index += 2
                             return "not", "not"
                         else
@@ -39,7 +39,7 @@ module JGrep
                         return "not", "not"
 
                     when "a"
-                        if (@arguments.split("")[@token_index + 1] == "n") && (@arguments.split("")[@token_index + 2] == "d") && ((@arguments.split("")[@token_index + 3] == " ") || (@arguments.split("")[@token_index + 3] == "("))
+                        if (chr(@arguments[@token_index + 1]) == "n") && (chr(@arguments[@token_index + 2]) == "d") && ((chr(@arguments[@token_index + 3]) == " ") || (chr(@arguments[@token_index + 3]) == "("))
                             @token_index += 2
                             return "and", "and"
                         else
@@ -47,7 +47,7 @@ module JGrep
                         end
 
                     when "&"
-                        if(@arguments.split("")[@token_index +1] == "&")
+                        if(chr(@arguments[@token_index +1]) == "&")
                             @token_index +=1
                             return "and", "and"
                         else
@@ -55,7 +55,7 @@ module JGrep
                         end
 
                     when "o"
-                        if (@arguments.split("")[@token_index + 1] == "r") && ((@arguments.split("")[@token_index + 2] == " ") || (@arguments.split("")[@token_index + 2] == "("))
+                        if (chr(@arguments[@token_index + 1]) == "r") && ((chr(@arguments[@token_index + 2]) == " ") || (chr(@arguments[@token_index + 2]) == "("))
                             @token_index += 1
                             return "or", "or"
                         else
@@ -63,7 +63,7 @@ module JGrep
                         end
 
                     when "|"
-                        if(@arguments.split("")[@token_index +1] == "|")
+                        if(chr(@arguments[@token_index +1]) == "|")
                             @token_index +=1
                             return "or", "or"
                         else
@@ -75,9 +75,9 @@ module JGrep
                         i = @token_index + 1
 
                         begin
-                            value +=  @arguments.split("")[i]
+                            value +=  chr(@arguments[i])
                             i += 1
-                        end until (i >= @arguments.size)  || (@arguments.split("")[i] =~ /\s|\)/)
+                        end until (i >= @arguments.size)  || (chr(@arguments[i]) =~ /\s|\)/)
 
                         @token_index = i - 1
                         return "+", value
@@ -87,9 +87,9 @@ module JGrep
                         i = @token_index + 1
 
                         begin
-                            value +=  @arguments.split("")[i]
+                            value +=  chr(@arguments[i])
                             i += 1
-                        end until (i >= @arguments.size)  || (@arguments.split("")[i] =~ /\s|\)/)
+                        end until (i >= @arguments.size)  || (chr(@arguments[i]) =~ /\s|\)/)
 
                         @token_index = i - 1
                         return "-", value
@@ -124,26 +124,26 @@ module JGrep
             j = @token_index
 
             begin
-                if (@arguments.split("")[j] == "/")
+                if (chr(@arguments[j]) == "/")
                     begin
-                        current_token_value << @arguments.split("")[j]
+                        current_token_value << chr(@arguments[j])
                         j += 1
-                        if @arguments.split("")[j] == "/"
+                        if chr(@arguments[j]) == "/"
                             current_token_value << "/"
                             break
                         end
-                    end until (j >= @arguments.size) || (@arguments.split("")[j] =~ /\//)
+                    end until (j >= @arguments.size) || (chr(@arguments[j]) =~ /\//)
                 else
                     begin
-                        current_token_value << @arguments.split("")[j]
+                        current_token_value << chr(@arguments[j])
                         j += 1
-                        if @arguments.split("")[j] =~ /'|"/
+                        if chr(@arguments[j]) =~ /'|"/
                             begin
-                                current_token_value << @arguments.split("")[j]
+                                current_token_value << chr(@arguments[j])
                                 j +=1
-                            end until (j >= @arguments.size) || (@arguments.split("")[j] =~ /'|"/)
+                            end until (j >= @arguments.size) || (chr(@arguments[j]) =~ /'|"/)
                         end
-                    end until (j >= @arguments.size) || (@arguments.split("")[j] =~ /\s|\)|\]/)
+                    end until (j >= @arguments.size) || (chr(@arguments[j]) =~ /\s|\)|\]/)
                 end
             rescue Exception => e
                 raise "Invalid token found - '#{current_token_value}'"
@@ -156,5 +156,10 @@ module JGrep
             @token_index += current_token_value.size - 1
             return "statement", current_token_value
         end
+
+        # Compatibility with 1.8.7, which returns a Fixnum from String#[]
+        def chr(character)
+          character.chr unless character.nil?
+        end
     end
 end

data/spec/Rakefile

@@ -0,0 +1,11 @@
+require "spec_helper.rb"
+require "rake"
+require "rspec/core/rake_task"
+
+desc "Run JGrep tests"
+RSpec::Core::RakeTask.new(:test) do |t|
+    t.pattern = "unit/*_spec.rb"
+    t.rspec_opts = "--format s --color --backtrace"
+end
+
+task :default => :test

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require "rubygems"
+require "rspec"
+require "rspec/mocks"
+require "mocha"
+require File.dirname(__FILE__) + "/../lib/jgrep"
+
+RSpec.configure do |config|
+    config.mock_with :mocha
+end
+

data/spec/unit/jgrep_spec.rb

@@ -0,0 +1,243 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + "/../spec_helper"
+
+module JGrep
+    describe JGrep do
+        describe "#jgrep" do
+
+            it "should return a valid json document" do
+                result = JGrep::jgrep("[{\"foo\":1}]", "foo=1")
+                result.should == [{"foo"=>1}]
+            end
+
+            it "should fail on an invalid json document" do
+                STDERR.expects(:puts).with("Error. Invalid JSON given")
+                result = JGrep::jgrep("[foo:]", "foo=1")
+            end
+
+            it "should return '[]' if value is not present in document" do
+                result = JGrep::jgrep("[{\"bar\":1}]", "foo=1")
+                result.should == []
+            end
+
+            it "should correctly return 'null' if a null value is present in the document" do
+                result = JGrep::jgrep("[{\"foo\":null}]", "foo=null")
+                result.should == [{"foo" => nil}]
+            end
+
+            it "should return the origional json document if no expression is given" do
+                result = JGrep::jgrep("[{\"foo\":\"bar\"}]", "")
+                result.should == [{"foo" => "bar"}]
+            end
+
+            it "should filter on the origional json document if not expression is given and a filter is given" do
+                result = JGrep::jgrep("[{\"foo\":\"bar\"}]", "", "foo")
+                result.should == ["bar"]
+            end
+
+            it "should support starting from a subdocument" do
+                doc = %q(
+                        {"results": [
+                                {"foo":"bar"},
+                                {"foo":"baz"}
+                                ]
+                        }
+                )
+
+                JGrep.verbose_on
+                results = JGrep::jgrep(doc, "foo=bar", nil, "results")
+                results.should == [{"foo"=>"bar"}]
+            end
+        end
+
+        describe "#format" do
+
+            it "should correctly format integers" do
+                result1, result2 = JGrep::format("1",1)
+                result1.is_a?(Fixnum).should == true
+                result2.is_a?(Fixnum).should == true
+            end
+
+            it "should correctly format floating point numbers" do
+                result1, result2 = JGrep::format("1.1", 1.1)
+                result1.is_a?(Float).should == true
+                result2.is_a?(Float).should == true
+            end
+
+            it "should not format strings" do
+                result1, result2 = JGrep::format("foo", "bar")
+                result1.is_a?(String).should == true
+                result2.is_a?(String).should == true
+            end
+        end
+
+        describe "#has_object?" do
+
+            it "should compare on a '=' operator" do
+                result = JGrep::has_object?({"foo"=> 1}, "foo=1")
+                result.should == true
+            end
+
+            it "should compare on a '<=' operator" do
+                result = JGrep::has_object?({"foo"=> 1}, "foo<=0")
+                result.should == false
+            end
+
+            it "should compare on a '>=' operator" do
+                result = JGrep::has_object?({"foo"=> 1}, "foo>=0")
+                result.should == true
+            end
+
+            it "should compare on a '<' operator" do
+                result = JGrep::has_object?({"foo"=> 1}, "foo<1")
+                result.should == false
+            end
+
+            it "should compare on a '>' operator" do
+                result = JGrep::has_object?({"foo"=> 1}, "foo>0")
+                result.should == true
+            end
+
+            it "should compare based on regular expression" do
+                result = JGrep::has_object?({"foo"=> "bar"}, "foo=/ba/")
+                result.should == true
+            end
+
+            it "should compare true booleans" do
+                result = JGrep::has_object?({"foo"=> true}, "foo=true")
+                result.should == true
+                result = JGrep::has_object?({"foo"=> false}, "foo=true")
+                result.should == false
+            end
+
+            it "should compare true booleans" do
+                result = JGrep::has_object?({"foo"=> false}, "foo=false")
+                result.should == true
+                result = JGrep::has_object?({"foo"=> true}, "foo=false")
+                result.should == false
+            end
+        end
+
+        describe "#is_object_in_array?" do
+
+            it "should return true if key=value is present in array" do
+                result = JGrep::is_object_in_array?([{"foo" => 1},{"foo" => 0}], "foo=1")
+                result.should == true
+            end
+
+            it "should return false if key=value is not present in array" do
+                result = JGrep::is_object_in_array?([{"foo" => 1},{"foo" => 0}], "foo=2")
+                result.should == false
+            end
+        end
+
+        describe "#has_complex?" do
+
+            it "should return true if complex statement is present in an array" do
+                result = JGrep::has_complex?({"foo" => ["bar" => 1]}, [["statement","foo.bar=1"]])
+                result.should == true
+            end
+
+            it "should return false if complex statement is not present in an array" do
+                result = JGrep::has_complex?({"foo" => ["bar" => 1]}, [["statement","foo.bar=0"]])
+                result.should == false
+            end
+        end
+
+        describe "#eval_statement" do
+
+            it "should return true if if document matches logical expression" do
+                result = JGrep::eval_statement({"foo" => 1, "bar" => 1}, [{"statement" => "foo=1"}, {"and" => "and"}, {"statement" => "bar=1"}])
+                result.should == true
+            end
+
+            it "should return true if if document matches logical expression array" do
+                result = JGrep::eval_statement({"foo" => ["bar" => 1]}, [{"statement" => [["statement", "foo.bar=1"]]}] )
+                result.should == true
+            end
+
+            it "should return false if if document doesn't match logical expression" do
+                result = JGrep::eval_statement({"foo" => 1, "bar" => 1}, [{"statement" => "foo=0"}, {"and" => "and"}, {"statement" => "bar=1"}])
+                result.should == false
+            end
+        end
+
+        describe "#filter_json" do
+            it "should return the correct values if there is a single filter" do
+                result = JGrep::filter_json([{"foo" => 1, "bar" => 1}], "foo")
+                result.should == [1]
+            end
+
+            it "should return the correct values if there are multiple filters" do
+                result = JGrep::filter_json([{"foo" => 1, "foo1" => 1, "foo2" => 1}], ["foo2", "foo1"])
+                result.should == [{"foo2"=>1, "foo1"=>1}]
+            end
+
+            it "should return an empty set if the filter has not been found and there is only 1 filter" do
+                result = JGrep::filter_json([{"foo" => 1}], "bar")
+                result.should == []
+            end
+
+            it "should not return a structure containing a key if that key is not specified in the document" do
+                result = JGrep::filter_json([{"foo" => 1}], ["foo", "bar"])
+                result.should == [{"foo" => 1}]
+            end
+        end
+
+        describe "#validate_filters" do
+
+            it "should validate correct single filter" do
+                result = JGrep::validate_filters("foo")
+                result.should be_nil
+            end
+
+            it "should not validate if a single filter contains an invalid field" do
+                expect{
+                    result = JGrep::validate_filters("and")
+                }.to raise_error "Invalid field for -s filter : 'and'"
+            end
+
+            it "should correctly validate an array of filters" do
+                result = JGrep::validate_filters(["foo", "bar"])
+                result.should be_nil
+            end
+
+            it "should not validate if an array of filters contain an illegal filter" do
+                expect{
+                    result = JGrep::validate_filters(["foo", "or"])
+                }.to raise_error "Invalid field for -s filter : 'or'"
+            end
+        end
+
+        describe "#dig_path" do
+
+            it "should return the correct key value for a hash" do
+                result = JGrep::dig_path({"foo" => 1}, "foo")
+                result.should == 1
+            end
+
+            it "should return the correct value for any value that is not a hash or an array" do
+                result = JGrep::dig_path(1, "foo")
+                result.should == 1
+            end
+
+            it "should return the correct value for a subvalue in an array" do
+                result = JGrep::dig_path([{"foo" => 1}, {"foo" => 2}], "foo")
+                result.should == [1,2]
+            end
+
+            it "should return the correct value if a wildcard is specified" do
+                result = JGrep::dig_path([{"foo" => {"bar" => 1}}], "foo.*")
+                result.should == [[{"bar"=>1}]]
+            end
+
+            it "should return the correct value if the path contains a dot seperated key" do
+                result = JGrep::dig_path({"foo.bar" => 1}, "foo.bar")
+                result.should == 1
+                result = JGrep::dig_path({"foo" => {"foo.bar" =>1}}, "foo.foo.bar")
+                result.should == 1
+            end
+        end
+    end
+end