command_search 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06faff1f0e62e2367a2a30bd36f28b0659e4d385c2e5d50ddbf2a3f73c8d7b88
-  data.tar.gz: 4a644540546ca3f4f1357640c2c5cde78e20bb2769e119a52552dd94ab8e9f35
+  metadata.gz: 747b007a76d4735046cb93429393b4b6ca85cb110efa57602f80535d2474bd3c
+  data.tar.gz: 3957d43828f6ce74718bfaed58ffd65072806c9cd8db3401e1913b57c8d05e2d
 SHA512:
-  metadata.gz: 57839d8fee294a20c5303a958b8b966aef308a0b3366f62e74803998265c41e03b43eb1dd4263f3f9065c14d0e6f761b55eb199ed971e5396b196e61758593d1
-  data.tar.gz: 8306e47f90008256cb30191329645d8fbb96083f7b68fb489b0b19241686eb9c0eaaccc5b111eddca26f82c75ed6e87e8d4304a0c20c1bd9061803a983484840
+  metadata.gz: 3c05e1d7b8adcbb822346980dc0b9efaa1f8dc9c58a27f6cc2cec5ce70bf87b49daa364f733a97bb58fc81bb45a93d2918db02c004d36bd65bb734d2484aced6
+  data.tar.gz: c8f2d50a7dcbdde4070dbe1fe1bbac1ce757475d4c07df3d256019c368e6c833b1c0e274fa1a4c9b9fbc996450ef354c03e47469c27f0997d5a95ed474412ecf

data/lib/command_search/memory.rb

@@ -111,7 +111,7 @@ module CommandSearch
         when :pipe
           val.any? { |v| check(item, v, fields, command_types) }
         when :minus
-          val.none? { |v| check(item, v, fields, command_types) }
+          !val.all? { |v| check(item, v, fields, command_types) }
         when :paren
           val.all? { |v| check(item, v, fields, command_types) }
         end

data/lib/command_search/mongoer.rb

@@ -27,29 +27,16 @@ module CommandSearch
       else
         regex = /#{Regexp.escape(str)}/i
       end
-      if ast_node[:negate]
-        forms = fields.map do |field|
-          if numeric_field?(field, command_types)
-            { field => { '$ne' => str } }
-          else
-            { field => { '$not' => regex } }
-          end
-        end
-      else
-        forms = fields.map do |field|
-          if numeric_field?(field, command_types)
-            { field => str }
-          else
-            { field => regex }
-          end
+
+      forms = fields.map do |field|
+        if numeric_field?(field, command_types)
+          { field => str }
+        else
+          { field => regex }
         end
       end
       return forms if forms.count < 2
-      if ast_node[:negate]
-        { '$and' => forms }
-      else
-        { '$or' => forms }
-      end
+      { '$or' => forms }
     end
 
     def is_bool_str?(str)
@@ -79,20 +66,14 @@ module CommandSearch
 
       if type == Boolean
         bool = make_boolean(raw_val)
-        bool = !bool if field_node[:negate]
         val = [
           { key => { '$exists' => true } },
           { key => { '$ne' => !bool } }
         ]
         key = '$and'
       elsif is_bool
-        # This returns true for empty arrays, when it probably should not.
-        # Alternativly, something like tags>5 could return things that have more
-        # than 5 tags in the array.
-        # https://stackoverflow.com/questions/22367335/mongodb-check-if-value-exists-for-a-field-in-a-document
-        # val = { '$exists' => make_boolean(raw_val) }
+        # These queries return true for empty arrays.
         bool = make_boolean(raw_val)
-        bool = !bool if field_node[:negate]
         if bool
           val = [
             { key => { '$exists' => true } },
@@ -132,27 +113,13 @@ module CommandSearch
           date_begin = date.begin
           date_end = date.end
         end
-        if field_node[:negate]
-          val = [
-            { key => { '$gt' => date_end   } },
-            { key => { '$lt' => date_begin } }
-          ]
-          key = '$or'
-        else
-          val = [
-            { key => { '$gte' => date_begin } },
-            { key => { '$lte' => date_end   } }
-          ]
-          key = '$and'
-        end
-      end
-      if field_node[:negate] && [Numeric, Integer].include?(type)
-        { key => { '$ne' => val } }
-      elsif field_node[:negate] && type == String
-        { key => { '$not' => val } }
-      else
-        { key => val }
+        val = [
+          { key => { '$gte' => date_begin } },
+          { key => { '$lte' => date_end   } }
+        ]
+        key = '$and'
       end
+      { key => val }
     end
 
     def build_compare(ast_node, command_types)
@@ -162,12 +129,6 @@ module CommandSearch
         '<=' => '>=',
         '>=' => '<='
       }
-      reverse_ops = {
-        '<' => '>=',
-        '<=' => '>',
-        '>' => '<=',
-        '>=' => '<'
-      }
       mongo_op_map = {
         '<' => '$lt',
         '>' => '$gt',
@@ -180,7 +141,6 @@ module CommandSearch
       key = first_node[:value]
       val = last_node[:value]
       op = ast_node[:nest_op]
-      op = reverse_ops[op] if first_node[:negate]
 
       if keys.include?(val.to_sym)
         (key, val) = [val, key]
@@ -254,46 +214,29 @@ module CommandSearch
     end
 
     def build_tree!(ast)
-      mongo_types = { paren: '$and', pipe: '$or', minus: '$not' }
-      ast.each do |x|
-        next x unless x[:nest_type]
-        build_tree!(x[:value])
-        key = mongo_types[x[:nest_type]]
-        x[key] = x[:value]
-        x.delete(:nest_type)
-        x.delete(:nest_op)
-        x.delete(:value)
-        x.delete(:type)
-      end
-    end
-
-    def collapse_ors!(ast)
-      ast.each do |x|
-        next unless x['$or']
-        x['$or'].map! { |kid| kid['$or'] || kid }.flatten!
-      end
-    end
-
-    def decompose_nots(ast, not_depth = 0)
-      ast.flat_map do |x|
-        if x[:nest_type] == :minus
-          decompose_nots(x[:value], not_depth + 1)
-        elsif x[:nest_type]
-          x[:value] = decompose_nots(x[:value], not_depth)
-          x
+      mongo_types = { paren: '$and', pipe: '$or', minus: '$nor' }
+      ast.each do |node|
+        next node unless node[:nest_type]
+        build_tree!(node[:value])
+        key = mongo_types[node[:nest_type]]
+        if key == '$nor' && node[:value].count > 1
+          node[key] = [{ '$and' => node[:value] }]
         else
-          x[:negate] = not_depth.odd?
-          x
+          node[key] = node[:value]
         end
+        node['$or'].map! { |x| x['$or'] || x }.flatten! if node['$or']
+        node['$nor'].map! { |x| x['$or'] || x }.flatten! if node['$nor']
+        node.delete(:nest_type)
+        node.delete(:nest_op)
+        node.delete(:value)
+        node.delete(:type)
       end
     end
 
     def build_query(ast, fields, command_types = {})
       out = ast
-      out = decompose_nots(out)
       build_searches!(out, fields, command_types)
       build_tree!(out)
-      collapse_ors!(out)
       out = {} if out == []
       out = out.first if out.count == 1
       out = { '$and' => out } if out.count > 1

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: command_search
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
 platform: ruby
 authors:
 - zumbalogy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-08 00:00:00.000000000 Z
+date: 2019-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chronic