jgrep 1.3.3 → 1.4.0

data/spec/unit/parser_spec.rb

@@ -0,0 +1,132 @@
+#! /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
+    end
+end

data/spec/unit/scanner_spec.rb

@@ -0,0 +1,91 @@
+#! /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
+    end
+end

metadata

@@ -1,85 +1,77 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: jgrep
-version: !ruby/object:Gem::Version 
-  hash: 29
-  prerelease: false
-  segments: 
-  - 1
-  - 3
-  - 3
-  version: 1.3.3
+version: !ruby/object:Gem::Version
+  version: 1.4.0
 platform: ruby
-authors: 
+authors:
 - P Loubser
+- Dominic Cleal
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-09-26 00:00:00 +01:00
-default_executable: jgrep
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2015-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: json
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-description: Compare a list of json documents to a simple logical language and returns matches as output
-email: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Compare a list of json documents to a simple logical language and returns
+  matches as output
+email:
 - ploubser@gmail.com
-executables: 
+- dominic@cleal.org
+executables:
 - jgrep
 extensions: []
-
-extra_rdoc_files: []
-
-files: 
-- jgrep.gemspec
+extra_rdoc_files:
+- CHANGELOG.markdown
+- README.markdown
+files:
+- CHANGELOG.markdown
+- COPYING
+- README.markdown
+- Rakefile
 - bin/jgrep
 - lib/jgrep.rb
-- lib/parser/scanner.rb
 - lib/parser/parser.rb
-has_rdoc: true
-homepage: https://github.com/psy1337/JSON-Grep
-licenses: []
-
+- lib/parser/scanner.rb
+- spec/Rakefile
+- spec/spec_helper.rb
+- spec/unit/jgrep_spec.rb
+- spec/unit/parser_spec.rb
+- spec/unit/scanner_spec.rb
+homepage: https://github.com/ploubser/JSON-Grep
+licenses:
+- Apache-2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 2.2.1
 signing_key: 
-specification_version: 3
-summary: Compare a list of json documents to a simple logical language and returns matches as output
+specification_version: 4
+summary: Filter JSON documents with a simple logical language
 test_files: []
-

data/jgrep.gemspec

@@ -1,17 +0,0 @@
-Gem::Specification.new do |s|
-    s.name = "jgrep"
-    s.version = "1.3.3"
-
-    s.authors = ["P Loubser"]
-    s.date = %q{2012-09-26}
-    s.default_executable = "jgrep"
-    s.add_dependency('json')
-    s.description = "Compare a list of json documents to a simple logical language and returns matches as output"
-    s.email = ["ploubser@gmail.com"]
-    s.executables = ["jgrep"]
-    s.files = ["jgrep.gemspec", "bin/jgrep", Dir.glob("lib/*"), Dir.glob("lib/parser/*")].flatten
-    s.has_rdoc = true
-    s.homepage = "https://github.com/psy1337/JSON-Grep"
-    s.require_paths = ["lib"]
-    s.summary = s.description
-end