jgrep 1.4.1 → 1.5.4

data/spec/unit/parser_spec.rb

@@ -1,132 +1,137 @@
-#! /usr/bin/env ruby
-
 require File.dirname(__FILE__) + "/../spec_helper"
 
 module JGrep
-    describe Parser do
-        describe '#parse' do
-            it "should parse statements seperated by '='" do
-                parser = Parser.new("foo.bar=bar")
-                parser.execution_stack.should == [{"statement" => "foo.bar=bar"}]
-            end
-
-            it "should parse statements seperated by '<'" do
-                parser = Parser.new("foo.bar<1")
-                parser.execution_stack.should == [{"statement" => "foo.bar<1"}]
-            end
-
-            it "should parse statements seperated by '>'" do
-                parser = Parser.new("foo.bar>1")
-                parser.execution_stack.should == [{"statement" => "foo.bar>1"}]
-            end
-
-            it "should parse statements seperated by '<='" do
-                parser = Parser.new("foo.bar<=1")
-                parser.execution_stack.should == [{"statement" => "foo.bar<=1"}]
-            end
-
-            it "should parse statements seperated by '>='" do
-                parser = Parser.new("foo.bar>=1")
-                parser.execution_stack.should == [{"statement" => "foo.bar>=1"}]
-            end
-
-            it "should parse statement sperated by '!='" do
-                parser = Parser.new("foo.bar!=1")
-                parser.execution_stack.should == [{"not" => "not"}, {"statement" =>"foo.bar=1"}]
-            end
-
-            it "should parse a + token" do
-                parser = Parser.new("+foo")
-                parser.execution_stack.should == [{"+" => "foo"}]
-            end
-
-            it "should parse a - token" do
-                parser = Parser.new("-foo")
-                parser.execution_stack.should == [{"-" => "foo"}]
-            end
-
-            it "should parse a correct 'and' token" do
-                parser = Parser.new("foo.bar=123 and bar.foo=321")
-                parser.execution_stack.should == [{"statement" => "foo.bar=123"}, {"and" => "and"}, {"statement" => "bar.foo=321"}]
-            end
-
-            it "should not parse an incorrect and token" do
-                expect {
-                    parser = Parser.new("and foo.bar=1")
-                }.to raise_error("Error at column 12. \n Expression cannot start with 'and'")
-            end
-
-            it "should parse a correct 'or' token" do
-                parser = Parser.new("foo.bar=1 or bar.foo=1")
-                parser.execution_stack.should == [{"statement" => "foo.bar=1"}, {"or" => "or"}, {"statement" => "bar.foo=1"}]
-            end
-
-            it "should not parse an incorrect and token" do
-                expect {
-                    parser = Parser.new("or foo.bar=1")
-                }.to raise_error("Error at column 11. \n Expression cannot start with 'or'")
-            end
-
-            it "should parse a correct 'not' token" do
-                parser = Parser.new("! bar.foo=1")
-                parser.execution_stack.should == [{"not" => "not"}, {"statement" => "bar.foo=1"}]
-                parser = Parser.new("not bar.foo=1")
-                parser.execution_stack.should == [{"not" => "not"}, {"statement" => "bar.foo=1"}]
-            end
-
-            it "should not parse an incorrect 'not' token" do
-                expect {
-                    parser = Parser.new("foo.bar=1 !")
-                }.to raise_error("Error at column 10. \nExpected 'and', 'or', ')'. Found 'not'")
-            end
-
-            it "should parse correct parentheses" do
-                parser = Parser.new("(foo.bar=1)")
-                parser.execution_stack.should == [{"(" => "("}, {"statement" => "foo.bar=1"}, {")" => ")"}]
-            end
-
-            it "should fail on incorrect parentheses" do
-                expect {
-                    parser = Parser.new(")foo.bar=1(")
-                }.to raise_error("Error. Missing parentheses '('.")
-            end
-
-            it "should fail on missing parentheses" do
-                expect {
-                    parser = Parser.new("(foo.bar=1")
-                }.to raise_error("Error. Missing parentheses ')'.")
-            end
-
-            it "should parse correctly formatted compound statements" do
-                parser = Parser.new("(foo.bar=1 or foo.rab=1) and (bar.foo=1)")
-                parser.execution_stack.should == [{"(" => "("}, {"statement"=>"foo.bar=1"}, {"or"=>"or"}, {"statement"=>"foo.rab=1"},
-                    {")"=>")"}, {"and"=>"and"}, {"("=>"("}, {"statement"=>"bar.foo=1"},
-                    {")"=>")"}]
-            end
-
-            it "should parse complex array statements" do
-                parser = Parser.new("[foo.bar=1]")
-                parser.execution_stack.should == [{"statement" => [["statement","foo.bar=1"]]}]
-            end
-
-            it "should not parse failed complex array statements" do
-                expect{
-                    parser = Parser.new("[foo.bar=1 or]")
-                }.to raise_error("Class name cannot be 'and', 'or', 'not'. Found 'or'")
-
-            end
-
-            it "should not allow nested complex array statements" do
-                expect{
-                    parser = Parser.new("[foo.bar=1 and [foo.bar=1]]")
-                }.to raise_error("Error at column 27\nError, cannot define '[' in a '[...]' block.")
-
-            end
-
-            it "should parse complex, compound array statements" do
-                parser = Parser.new("[foo.bar=1 and foo.rab=2] and !(foo=1)")
-                parser.execution_stack.should == [{"statement"=>[["statement", "foo.bar=1"], ["and", "and"], ["statement", "foo.rab=2"]]}, {"and"=>"and"}, {"not"=>"not"}, {"("=>"("}, {"statement"=>"foo=1"}, {")"=>")"}]
-            end
-        end
+  describe Parser do
+    describe "#parse" do
+      it "should parse statements seperated by '='" do
+        parser = Parser.new("foo.bar=bar")
+        expect(parser.execution_stack).to eq([{"statement" => "foo.bar=bar"}])
+      end
+
+      it "should parse statements seperated by '<'" do
+        parser = Parser.new("foo.bar<1")
+        expect(parser.execution_stack).to eq([{"statement" => "foo.bar<1"}])
+      end
+
+      it "should parse statements seperated by '>'" do
+        parser = Parser.new("foo.bar>1")
+        expect(parser.execution_stack).to eq([{"statement" => "foo.bar>1"}])
+      end
+
+      it "should parse statements seperated by '<='" do
+        parser = Parser.new("foo.bar<=1")
+        expect(parser.execution_stack).to eq([{"statement" => "foo.bar<=1"}])
+      end
+
+      it "should parse statements seperated by '>='" do
+        parser = Parser.new("foo.bar>=1")
+        expect(parser.execution_stack).to eq([{"statement" => "foo.bar>=1"}])
+      end
+
+      it "should parse statement sperated by '!='" do
+        parser = Parser.new("foo.bar!=1")
+        expect(parser.execution_stack).to eq([{"not" => "not"}, {"statement" => "foo.bar=1"}])
+      end
+
+      it "should parse a + token" do
+        parser = Parser.new("+foo")
+        expect(parser.execution_stack).to eq([{"+" => "foo"}])
+      end
+
+      it "should parse a - token" do
+        parser = Parser.new("-foo")
+        expect(parser.execution_stack).to eq([{"-" => "foo"}])
+      end
+
+      it "should parse a correct 'and' token" do
+        parser = Parser.new("foo.bar=123 and bar.foo=321")
+        expect(parser.execution_stack).to eq([{"statement" => "foo.bar=123"}, {"and" => "and"}, {"statement" => "bar.foo=321"}])
+      end
+
+      it "should not parse an incorrect and token" do
+        expect do
+          Parser.new("and foo.bar=1")
+        end.to raise_error("Error at column 12. \n Expression cannot start with 'and'")
+      end
+
+      it "should parse a correct 'or' token" do
+        parser = Parser.new("foo.bar=1 or bar.foo=1")
+        expect(parser.execution_stack).to eq([{"statement" => "foo.bar=1"}, {"or" => "or"}, {"statement" => "bar.foo=1"}])
+      end
+
+      it "should not parse an incorrect and token" do
+        expect do
+          Parser.new("or foo.bar=1")
+        end.to raise_error("Error at column 11. \n Expression cannot start with 'or'")
+      end
+
+      it "should parse a correct 'not' token" do
+        parser = Parser.new("! bar.foo=1")
+        expect(parser.execution_stack).to eq([{"not" => "not"}, {"statement" => "bar.foo=1"}])
+        parser = Parser.new("not bar.foo=1")
+        expect(parser.execution_stack).to eq([{"not" => "not"}, {"statement" => "bar.foo=1"}])
+      end
+
+      it "should not parse an incorrect 'not' token" do
+        expect do
+          Parser.new("foo.bar=1 !")
+        end.to raise_error("Error at column 10. \nExpected 'and', 'or', ')'. Found 'not'")
+      end
+
+      it "should parse correct parentheses" do
+        parser = Parser.new("(foo.bar=1)")
+        expect(parser.execution_stack).to eq([{"(" => "("}, {"statement" => "foo.bar=1"}, {")" => ")"}])
+      end
+
+      it "should fail on incorrect parentheses" do
+        expect do
+          Parser.new(")foo.bar=1(")
+        end.to raise_error("Error. Missing parentheses '('.")
+      end
+
+      it "should fail on missing parentheses" do
+        expect do
+          Parser.new("(foo.bar=1")
+        end.to raise_error("Error. Missing parentheses ')'.")
+      end
+
+      it "should parse correctly formatted compound statements" do
+        parser = Parser.new("(foo.bar=1 or foo.rab=1) and (bar.foo=1)")
+        expect(parser.execution_stack).to eq([{"(" => "("}, {"statement" => "foo.bar=1"}, {"or" => "or"}, {"statement" => "foo.rab=1"},
+                                              {")" => ")"}, {"and" => "and"}, {"(" => "("}, {"statement" => "bar.foo=1"},
+                                              {")" => ")"}])
+      end
+
+      it "should parse complex array statements" do
+        parser = Parser.new("[foo.bar=1]")
+        expect(parser.execution_stack).to eq([{"statement" => [["statement", "foo.bar=1"]]}])
+      end
+
+      it "should not parse failed complex array statements" do
+        expect do
+          Parser.new("[foo.bar=1 or]")
+        end.to raise_error("Class name cannot be 'and', 'or', 'not'. Found 'or'")
+      end
+
+      it "should not allow nested complex array statements" do
+        expect do
+          Parser.new("[foo.bar=1 and [foo.bar=1]]")
+        end.to raise_error("Error at column 27\nError, cannot define '[' in a '[...]' block.")
+      end
+
+      it "should parse complex, compound array statements" do
+        parser = Parser.new("[foo.bar=1 and foo.rab=2] and !(foo=1)")
+        expect(parser.execution_stack).to eq(
+          [
+            {"statement" => [["statement", "foo.bar=1"], %w[and and], ["statement", "foo.rab=2"]]},
+            {"and" => "and"},
+            {"not" => "not"},
+            {"(" => "("},
+            {"statement" => "foo=1"},
+            {")" => ")"}
+          ]
+        )
+      end
     end
+  end
 end

data/spec/unit/scanner_spec.rb

@@ -1,91 +1,93 @@
-#! /usr/bin/env ruby
-
 require File.dirname(__FILE__) + "/../spec_helper"
 
-
 module JGrep
-    describe Scanner do
-        describe '#get_token' do
-            it "should identify a '(' token" do
-                scanner = Scanner.new("(")
-                token = scanner.get_token
-                token.should == ["(", "("]
-            end
-
-            it "should identify a ')' token" do
-                scanner = Scanner.new(")")
-                token = scanner.get_token
-                token.should == [")", ")"]
-            end
-
-            it "should identify an 'and' token" do
-                scanner = Scanner.new("and ")
-                token = scanner.get_token
-                token.should == ["and", "and"]
-            end
-
-            it "should identify a '&&' token" do
-                scanner = Scanner.new("&& ")
-                token = scanner.get_token
-                token.should == ["and", "and"]
-            end
-
-            it "should identify an 'or' token" do
-                scanner = Scanner.new("or ")
-                token = scanner.get_token
-                token.should == ["or", "or"]
-            end
-
-            it "should identify a "||" token" do
-                scanner = Scanner.new("|| ")
-                token = scanner.get_token
-                token.should == ["or", "or"]
-
-            end
-
-            it "should identify an 'not' token" do
-                scanner = Scanner.new("not ")
-                token = scanner.get_token
-                token.should == ["not", "not"]
-            end
-
-            it "should identify an '!' token" do
-                scanner = Scanner.new("!")
-                token = scanner.get_token
-                token.should == ["not", "not"]
-            end
-
-            it "should identify a statement token" do
-                scanner = Scanner.new("foo.bar=bar")
-                token = scanner.get_token
-                token.should == ["statement", "foo.bar=bar"]
-            end
-
-            it "should identify a complex array statement" do
-                scanner = Scanner.new("[foo=bar and bar=foo]")
-                token = scanner.get_token
-                token.should == ["statement", [["statement", "foo=bar"], ["and", "and"], ["statement", "bar=foo"]]]
-            end
-
-            it "should fail if expression terminates with 'and'" do
-                scanner = Scanner.new("and")
-
-                expect {
-                    token = scanner.get_token
-                }.to raise_error("Class name cannot be 'and', 'or', 'not'. Found 'and'")
-            end
-
-            it "should identify a '+' token" do
-                scanner = Scanner.new("+foo")
-                token = scanner.get_token
-                token.should == ["+","foo"]
-            end
-
-            it "should identify a '-' token" do
-                scanner = Scanner.new("-foo")
-                token = scanner.get_token
-                token.should == ["-", "foo"]
-            end
-        end
+  describe Scanner do
+    describe "#get_token" do
+      it "should identify a '(' token" do
+        scanner = Scanner.new("(")
+        token = scanner.get_token
+        expect(token).to eq(["(", "("])
+      end
+
+      it "should identify a ')' token" do
+        scanner = Scanner.new(")")
+        token = scanner.get_token
+        expect(token).to eq([")", ")"])
+      end
+
+      it "should identify an 'and' token" do
+        scanner = Scanner.new("and ")
+        token = scanner.get_token
+        expect(token).to eq(%w[and and])
+      end
+
+      it "should identify a '&&' token" do
+        scanner = Scanner.new("&& ")
+        token = scanner.get_token
+        expect(token).to eq(%w[and and])
+      end
+
+      it "should identify an 'or' token" do
+        scanner = Scanner.new("or ")
+        token = scanner.get_token
+        expect(token).to eq(%w[or or])
+      end
+
+      it "should identify a " || " token" do
+        scanner = Scanner.new("|| ")
+        token = scanner.get_token
+        expect(token).to eq(%w[or or])
+      end
+
+      it "should identify an 'not' token" do
+        scanner = Scanner.new("not ")
+        token = scanner.get_token
+        expect(token).to eq(%w[not not])
+      end
+
+      it "should identify an '!' token" do
+        scanner = Scanner.new("!")
+        token = scanner.get_token
+        expect(token).to eq(%w[not not])
+      end
+
+      it "should identify a statement token" do
+        scanner = Scanner.new("foo.bar=bar")
+        token = scanner.get_token
+        expect(token).to eq(["statement", "foo.bar=bar"])
+      end
+
+      it "should identify a statement token with escaped parentheses" do
+        scanner = Scanner.new("foo.bar=/baz\\(gronk\\)quux/")
+        token = scanner.get_token
+        expect(token).to eq(["statement", "foo.bar=/baz\\(gronk\\)quux/"])
+      end
+
+      it "should identify a complex array statement" do
+        scanner = Scanner.new("[foo=bar and bar=foo]")
+        token = scanner.get_token
+        expect(token).to eq(["statement", [["statement", "foo=bar"], %w[and and], ["statement", "bar=foo"]]])
+      end
+
+      it "should fail if expression terminates with 'and'" do
+        scanner = Scanner.new("and")
+
+        expect do
+          scanner.get_token
+        end.to raise_error("Class name cannot be 'and', 'or', 'not'. Found 'and'")
+      end
+
+      it "should identify a '+' token" do
+        scanner = Scanner.new("+foo")
+        token = scanner.get_token
+        expect(token).to eq(["+", "foo"])
+      end
+
+      it "should identify a '-' token" do
+        scanner = Scanner.new("-foo")
+        token = scanner.get_token
+        expect(token).to eq(["-", "foo"])
+      end
     end
+  end
 end

metadata

@@ -1,35 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: jgrep
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.4
 platform: ruby
 authors:
 - P Loubser
 - Dominic Cleal
+- R.I. Pienaar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-17 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2020-09-10 00:00:00.000000000 Z
+dependencies: []
 description: Compare a list of json documents to a simple logical language and returns
   matches as output
 email:
 - ploubser@gmail.com
 - dominic@cleal.org
+- rip@devco.net
 executables:
 - jgrep
 extensions: []
@@ -69,8 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Filter JSON documents with a simple logical language