mongo-parser-rb 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3a58b44007f8b742abfe589c9182b839a70eaa9
-  data.tar.gz: f2e40e2eb6870f62b0daf5ac4ff7311ddd0484e9
+  metadata.gz: 377864fec17861222eb64d45223d527e95e1fc53
+  data.tar.gz: 96bbf223ea627086c2107a43e720b877986b5587
 SHA512:
-  metadata.gz: 7d21bbdf37312f90431e1cd9c7843ceca3a512173e77a2fe6f01c39683198f9a62d691c5c65e8e4ac8b5d9403a81f45e505c99bfb164cfa5087e9e632bf6cf18
-  data.tar.gz: d5b1516dba68c439e41f764577558a3c2fd438091ded9e40d819ce12d65a8733484c37bd83c4b7a03d6214414c91b853d4037249a59b5839e0812a7f594cc03b
+  metadata.gz: 4625ff07d26acb1a8e632b5e02ccbe8c3965a03dd3dd5ecdcd6d008e29be1f361dcd23b00f65237322e791e82d6895e58db9454a944ee2bc36166f57869eb7ed
+  data.tar.gz: 2b35a891d28081c32956e64a5efef2bd9692b7bb5a2d68ba1b05823f91ce4609e353fccb4e429f1a8aa8932d3f2b2230a97825819efad38aa7eb7ee6b0827def

data/Rakefile

@@ -9,3 +9,9 @@ Rake::TestTask.new("test") do |test|
   test.warning = false
   test.verbose = true
 end
+
+
+desc "Run some performance tests"
+task :perf do
+  require_relative 'performance/perf.rb'
+end

data/lib/mongo-parser-rb.rb

@@ -1,8 +1,8 @@
-require "mongo-parser-rb/version"
-require "mongo-parser-rb/exceptions"
-require "mongo-parser-rb/field"
-require "mongo-parser-rb/query/expression"
-require "mongo-parser-rb/query"
+require_relative "mongo-parser-rb/version"
+require_relative "mongo-parser-rb/exceptions"
+require_relative "mongo-parser-rb/field"
+require_relative "mongo-parser-rb/query/expression"
+require_relative "mongo-parser-rb/query"
 
 module MongoParserRB
 end

data/lib/mongo-parser-rb/field.rb

@@ -7,7 +7,6 @@ module MongoParserRB
     end
 
     def value_in_document(document)
-      document = stringify_keys(document)
       @field_parts.reduce(document) do |value, field|
         case value
         when Array
@@ -22,8 +21,6 @@ module MongoParserRB
     end
 
     def in_document?(document)
-      document = stringify_keys(document)
-
       @field_parts.reduce(document) do |value, field|
         return false unless value.has_key?(field)
         value[field]
@@ -32,22 +29,5 @@ module MongoParserRB
       true
     end
 
-    private
-
-    def stringify_keys(document)
-      document.reduce({}) do |new_document, (k,v)|
-        new_document[k.to_s] = case v
-        when Hash
-          stringify_keys(v)
-        when Array
-          v.map { |e| e.kind_of?(Hash) ? stringify_keys(e) : e }
-        else
-          v
-        end
-
-        new_document
-      end
-    end
-
   end
 end

data/lib/mongo-parser-rb/query.rb

@@ -31,9 +31,11 @@ module MongoParserRB
     # @return [Boolean]
     def matches_document?(document)
       raise NotParsedError, "Query not parsed (run parse!)" if @expression_tree.nil?
+
+      document = stringify_keys(document)
       @expression_tree.evaluate(document)
     end
-    
+
     private
 
     def parse_root_expression(query, field = nil)
@@ -43,17 +45,17 @@ module MongoParserRB
     end
 
     def parse_sub_expression(key, value, field = nil)
-      if Expression.operator?(key)
-        case key 
-        when *Expression.conjunction_operators
+      if Expression::ALL_OPERATORS.include?(key)
+        case key
+        when *Expression::CONJUNCTION_OPERATORS
           Expression.new(key, value.map { |v| parse_root_expression(v) })
-        when *Expression.inversion_operators
+        when *Expression::INVERSION_OPERATORS
           if value.kind_of?(Hash)
             Expression.new(:$not, field, parse_root_expression(value, field))
           else
             Expression.new(:$not, field, Expression.new(:$eq, field, value))
           end
-        when *Expression.elemMatch_operators
+        when *Expression::ELEM_MATCH_OPERATORS
           Expression.new(:$elemMatch, field, value.to_a.map do |(key, value)|
             parse_sub_expression(key, value)
           end)
@@ -67,5 +69,20 @@ module MongoParserRB
       end
     end
 
+    def stringify_keys(document)
+      document.reduce({}) do |new_document, (k,v)|
+        new_document[k.to_s] = case v
+        when Hash
+          stringify_keys(v)
+        when Array
+          v.map { |e| e.kind_of?(Hash) ? stringify_keys(e) : e }
+        else
+          v
+        end
+
+        new_document
+      end
+    end
+
   end
 end

data/lib/mongo-parser-rb/query/expression.rb

@@ -2,71 +2,17 @@ module MongoParserRB
   class Query
     class Expression
 
-      class << self
-
-        def inversion_operators
-          @inversion_operators ||= [
-            :$not
-          ]
-        end
-
-        def inversion_operator?(operator)
-          inversion_operators.include?(operator)
-        end
-
-        def conjunction_operators
-          @conjunction_operators ||= [
-            :$and,
-            :$or
-          ]
-        end
-
-        def conjunction_operator?(operator)
-          conjunction_operators.include?(operator)
-        end
-
-        def negative_equality_operators
-          @negative_equality_operators ||= [
-            :$nin,
-            :$ne
-          ]
-        end
-
-        def equality_operators
-          @equality_operators ||= [
-            :$eq,
-            :$gt,
-            :$lt,
-            :$gte,
-            :$lte,
-            :$in
-          ] | negative_equality_operators
-        end
-
-        def equality_operator?(operator)
-          equality_operators.include?(operator)
-        end
-        
-        def elemMatch_operators
-          @elemMatch_operators ||= [
-            :$elemMatch
-          ]
-        end
-        
-        def elemMatch_operator?(operator)
-          elemMatch_operators.include?(operator)
-        end
-
-        def operator?(operator)
-          equality_operator?(operator) || conjunction_operator?(operator) || inversion_operator?(operator) || elemMatch_operator?(operator)
-        end
-
-      end
+      INVERSION_OPERATORS = [:$not].freeze
+      CONJUNCTION_OPERATORS = [:$and, :$or].freeze
+      NEGATIVE_EQUALITY_OPERATORS = [:$nin, :$ne].freeze
+      EQUALITY_OPERATORS = [:$eq, :$gt, :$lt, :$gte, :$lte, :$in, :$nin, :$ne].freeze
+      ELEM_MATCH_OPERATORS = [:$elemMatch].freeze
+      ALL_OPERATORS = [:$eq, :$gt, :$lt, :$gte, :$lte, :$in, :$nin, :$ne, :$and, :$or, :$not, :$elemMatch].freeze
 
       def initialize(operator, *args)
         @operator = operator
 
-        if Expression.conjunction_operator?(@operator)
+        if CONJUNCTION_OPERATORS.include?(@operator)
           @arguments = args[0]
         else
           @field = Field.new(args[0])
@@ -76,15 +22,15 @@ module MongoParserRB
 
       def evaluate(document)
         case @operator
-        when *Expression.conjunction_operators
+        when *Expression::CONJUNCTION_OPERATORS
           evaluate_conjunction(document)
-        when *Expression.negative_equality_operators
+        when *Expression::NEGATIVE_EQUALITY_OPERATORS
           evaluate_negative_equality(document)
-        when *Expression.equality_operators
+        when *Expression::EQUALITY_OPERATORS
           evaluate_equality(document)
-        when *Expression.inversion_operators
+        when *Expression::INVERSION_OPERATORS
           evaluate_inversion(document)
-        when *Expression.elemMatch_operators
+        when *Expression::ELEM_MATCH_OPERATORS
           evaluate_elemMatch(document)
         end
       rescue NoMethodError, TypeError
@@ -100,7 +46,7 @@ module MongoParserRB
           end
         end
       end
-      
+
       def evaluate_inversion(document)
         # Mongo negative equality operators return true when
         # the specified field does not exist on a document.
@@ -130,8 +76,7 @@ module MongoParserRB
           # the specified field does not exist on a document.
           return true if !value_for_field && !@field.in_document?(document)
 
-          if value_for_field.kind_of?(Array) && 
-             !@arguments.kind_of?(Array)
+          if value_for_field.kind_of?(Array) && !@arguments.kind_of?(Array)
             !value_for_field.include?(@arguments)
           else
             value_for_field != @arguments
@@ -152,8 +97,7 @@ module MongoParserRB
         when :$eq
           if @arguments.kind_of?(Regexp)
             !!(value_for_field =~ @arguments)
-          elsif value_for_field.kind_of?(Array) && 
-                !@arguments.kind_of?(Array)
+          elsif value_for_field.kind_of?(Array) && !@arguments.kind_of?(Array)
             value_for_field.include?(@arguments)
           else
             value_for_field == @arguments

data/lib/mongo-parser-rb/version.rb

@@ -1,3 +1,3 @@
 module MongoParserRB
-  VERSION = "0.0.11"
+  VERSION = "0.0.12"
 end

data/performance/perf.rb

@@ -0,0 +1,49 @@
+require 'benchmark'
+require_relative '../lib/mongo-parser-rb'
+
+iterations = 500_000
+
+Benchmark.bm(22) do |bm|
+  bm.report('simple query parsing') do
+    query_hash = {
+      :$or => [
+        { aaa: { :$gt => 20 } },
+        { bbb: {:$not => {:$gt => 10 }} },
+        { ccc: 11 },
+        { ddd: 12 },
+        { eee: 13 },
+        { :fff => { :$in => [1] } }
+      ]
+    }
+
+    iterations.times do
+      MongoParserRB::Query.parse(query_hash)
+    end
+  end
+
+  bm.report('simple query matching') do
+    query = MongoParserRB::Query.parse({
+      :$or => [
+        { aaa: { :$gt => 20 } },
+        { bbb: 10 },
+        { ccc: 11 },
+        { ddd: 12 },
+        { eee: 13 }
+      ]
+    })
+
+    document = {
+      aaa: 1, bbb: 2, ccc: 3, ddd: 4, eee: 5,
+      nested1: {
+        aaa: 1, bbb: 2, ccc: 3, ddd: 4, eee: 5,
+        nested: {
+          aaa: 1, bbb: 2, ccc: 3, ddd: 4, eee: 5
+        }
+      }
+    }
+
+    iterations.times do
+      query.matches_document?(document)
+    end
+  end
+end

data/test/mongo-parser-rb/field_test.rb

@@ -1,41 +1,41 @@
 require 'test_helper'
 
-class FieldTest < MiniTest::Unit::TestCase
+class FieldTest < Minitest::Test
 
   def test_returns_value_when_key_present
     field = MongoParserRB::Field.new(:"custom_data.tracked_users")
-    assert_equal 10, field.value_in_document(:custom_data => {:tracked_users => 10})
+    assert_equal 10, field.value_in_document('custom_data' => {'tracked_users' => 10})
   end
 
   def test_returns_nil_when_key_not_present
     field = MongoParserRB::Field.new(:"custom_data.tracked_users")
-    assert_nil field.value_in_document(:custom_data => {:something_else => 10})
-    assert_nil field.value_in_document(:name => "Ben")
+    assert_nil field.value_in_document('custom_data' => {'something_else' => 10})
+    assert_nil field.value_in_document('name' => "Ben")
   end
 
   def test_document_has_a_field
     field = MongoParserRB::Field.new(:"custom_data.tracked_users")
-    assert field.in_document?(:custom_data => {:tracked_users => 10})
-    refute field.in_document?(:not_custom_data => {:tracked_users => 10})
+    assert field.in_document?('custom_data' => {'tracked_users' => 10})
+    refute field.in_document?('not_custom_data' => {'tracked_users' => 10})
 
     field = MongoParserRB::Field.new(:"session_count")
-    assert field.in_document?(:custom_data => {:tracked_users => 10}, :session_count => 5)
-    refute field.in_document?(:custom_data => {:tracked_users => 10})
+    assert field.in_document?('custom_data' => {'tracked_users' => 10}, 'session_count' => 5)
+    refute field.in_document?('custom_data' => {'tracked_users' => 10})
   end
 
   def test_returning_array_element
     field = MongoParserRB::Field.new(:"something.array.0")
-    assert_equal 1, field.value_in_document(:something => {:array => [1,2]})
+    assert_equal 1, field.value_in_document('something' => {'array' => [1,2]})
   end
-  
+
   def test_returning_empty_array
     field = MongoParserRB::Field.new(:"something.array.name")
-    assert_equal [], field.value_in_document(:something => {:array => []})
+    assert_equal [], field.value_in_document('something' => {'array' => []})
   end
 
   def test_returning_hash_in_array
     field = MongoParserRB::Field.new(:"something.array.0.key")
-    document = {:something => {:array => [{:key => 'hello world'}, {:key => 'bye world'}]}}
+    document = {'something' => {'array' => [{'key' => 'hello world'}, {'key' => 'bye world'}]}}
     assert_equal 'hello world', field.value_in_document(document)
 
     field = MongoParserRB::Field.new(:"something.array.1.key")

data/test/mongo-parser-rb/query_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class QueryTest < MiniTest::Unit::TestCase
+class QueryTest < Minitest::Test
   def test_raises_if_not_parsed
     assert_raises(MongoParserRB::NotParsedError) do
       query = MongoParserRB::Query.new(:integer_key => 10)
@@ -113,6 +113,18 @@ class QueryTest < MiniTest::Unit::TestCase
     refute query.matches_document?(:integer_key => 5)
   end
 
+  def test_nested_or
+    query = MongoParserRB::Query.parse({
+      :$or=>[{ :name => 'cormac' }, { :name => 'john' }],
+      :anonymous => { :$in => [false, nil] },
+      :app_id => 6
+    })
+    assert query.matches_document?(:name => 'cormac', :app_id => 6)
+    assert query.matches_document?(:name => 'john', :app_id => 6)
+    refute query.matches_document?(:name => 'john', :app_id => 7)
+    refute query.matches_document?(:name => 'john', :app_id => 6, :anonymous => true)
+  end
+
   def test_boolean_eq
     query = MongoParserRB::Query.parse(:boolean_key => false)
     assert query.matches_document?(:boolean_key => false)
@@ -137,12 +149,12 @@ class QueryTest < MiniTest::Unit::TestCase
     refute query.matches_document?(:array_key => [1,4,5])
   end
 
-  def test_nil_by_absence_nin 
+  def test_nil_by_absence_nin
     query = MongoParserRB::Query.parse(:"custom_data.value" => {:$nin => [nil]})
     assert query.matches_document?(:custom_data => {:value => 5})
     refute query.matches_document?({})
   end
-  
+
   def test_nil_by_empty
     query = MongoParserRB::Query.parse({:"user_event_summaries.name" => {:$ne => "second-support"}})
     assert query.matches_document?({"user_event_summaries" => []})
@@ -224,19 +236,19 @@ class QueryTest < MiniTest::Unit::TestCase
     query = MongoParserRB::Query.parse(:array_key => {:$ne => [1]})
     assert query.matches_document?(:array_key => [1,2])
   end
-  
+
   def test_elemMatch
     query = MongoParserRB::Query.parse({:user_event_summaries => {:$elemMatch=> {:name => "second-support", :count => 3}}})
     refute query.matches_document?(:user_event_summaries => [{:name => "first-support", :count => 3}, {:name => "second-support", :count => 4}])
     assert query.matches_document?(:user_event_summaries => [{:name => "first-support", :count => 4}, {:name => "second-support", :count => 3}])
   end
-  
+
   def test_elemMatch_inequality
     query = MongoParserRB::Query.parse(:user_event_summaries => {:$elemMatch=> {:count => {:$ne => 2}, :name => "second-support"}})
     refute query.matches_document?(:user_event_summaries => [{:name => "first-support", :count => 3}, {:name => "second-support", :count => 2}])
     assert query.matches_document?(:user_event_summaries => [{:name => "first-support", :count => 3}, {:name => "second-support", :count => 3}])
   end
-  
+
   def test_datatype_mismatch
     query = MongoParserRB::Query.parse(:integer_key => {:$gt => 5})
     refute query.matches_document?(:integer_key => "hello")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongo-parser-rb
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Ben McRedmond
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-14 00:00:00.000000000 Z
+date: 2015-07-07 00:00:00.000000000 Z
 dependencies: []
 description: Parse and evaluate mongo queries in Ruby
 email:
@@ -17,8 +17,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .yardopts
+- ".gitignore"
+- ".yardopts"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -30,6 +30,7 @@ files:
 - lib/mongo-parser-rb/query/expression.rb
 - lib/mongo-parser-rb/version.rb
 - mongo-parser-rb.gemspec
+- performance/perf.rb
 - test/mongo-parser-rb/field_test.rb
 - test/mongo-parser-rb/query_test.rb
 - test/test_helper.rb
@@ -42,17 +43,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Parse and evaluate mongo queries in Ruby