command_search 0.8.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15ffe763615f2dbf119a8960fb91405376f2d2e30b3f43f594c6b3c7730ce96c
-  data.tar.gz: afe8f45ba3199a987b5ee2abbb7429fc13d89658d8dd0c48af74c19d3f4634ac
+  metadata.gz: b4560d75eabd25ff56808df06ab6b72d97813fbd75909739d15bfa2e13055557
+  data.tar.gz: 8c48236dd477f98450076128b7737121fabb16398c123e3c567f049bd68cadbf
 SHA512:
-  metadata.gz: 3b10c60d4c3cca7daea2f1d14b3fc87afbdaf79922f1fc2f6fb4b33b97af8983c61ce0140e5ec1234749bd1b738fe6f34b9f6932db7f7f5ec7b95492ad863e3b
-  data.tar.gz: ad4acd1ceeafa32f0982a9c076724b3b933177653e997f2d8a5c9635f61d3f17980e47285c32b375a1ec0a28765dd5eaf00f01c5a160d8cd7e9cc1f1c3cc04f2
+  metadata.gz: b0abdf98f95abba34b3a27d8f805f5183b1089e7291dad6b7f3a67e6cdb8a2413dad6813cf06e7118b733b44132428d79c89545739184022f3fc6d6222e60f8d
+  data.tar.gz: 836f1b245c14396850259c7e326e4ed1451bfcda6df07a594162ed4bbd1725abdf4a4a46c90c75c23eeb3b3a0ed242e7caa02cded714437acc1cc9ce65a63781

data/lib/command_search.rb

@@ -1,10 +1,11 @@
 load(__dir__ + '/command_search/aliaser.rb')
 load(__dir__ + '/command_search/lexer.rb')
 load(__dir__ + '/command_search/parser.rb')
-load(__dir__ + '/command_search/command_dealiaser.rb')
+load(__dir__ + '/command_search/normalizer.rb')
 load(__dir__ + '/command_search/optimizer.rb')
-load(__dir__ + '/command_search/mongoer.rb')
-load(__dir__ + '/command_search/memory.rb')
+
+load(__dir__ + '/command_search/backends/memory.rb')
+load(__dir__ + '/command_search/backends/mongoer.rb')
 
 class Boolean; end
 
@@ -17,19 +18,17 @@ module CommandSearch
     command_fields = options[:command_fields] || {}
 
     aliased_query = Aliaser.alias(query, aliases)
-    tokens = Lexer.lex(aliased_query)
-    parsed = Parser.parse!(tokens)
-    dealiased = CommandDealiaser.dealias(parsed, command_fields)
-    cleaned = CommandDealiaser.decompose_unaliasable(dealiased, command_fields)
-    opted = Optimizer.optimize(cleaned)
+    ast = Lexer.lex(aliased_query)
+    Parser.parse!(ast)
+    Optimizer.optimize!(ast)
+    command_fields = Normalizer.normalize!(ast, command_fields)
 
     if source.respond_to?(:mongo_client) && source.queryable
-      fields = [:__CommandSearch_mongo_fields_dummy_key__] if fields.empty?
-      mongo_query = Mongoer.build_query(opted, fields, command_fields)
+      fields = [:__CommandSearch_dummy_key__] if fields.empty?
+      mongo_query = Mongoer.build_query(ast, fields, command_fields)
       return source.where(mongo_query)
     end
 
-    selector = Memory.build_query(opted, fields, command_fields)
-    source.select(&selector)
+    source.select { |x| Memory.check(x, ast, fields, command_fields) }
   end
 end

data/lib/command_search/backends/memory.rb

@@ -0,0 +1,70 @@
+module CommandSearch
+  module Memory
+    module_function
+
+    def command_check(item, val)
+      cmd = val[0][:value]
+      cmd_search = val[1][:value]
+      item_val = item[cmd.to_sym] || item[cmd]
+      val_type = val[1][:type]
+      val_type = Boolean if val_type == :existence && cmd_search == true
+      if val_type == Boolean
+        !!item_val == cmd_search
+      elsif val_type == :existence
+        item_val == nil
+      elsif !item_val
+        return false
+      elsif val_type == Time
+        item_time = item_val.to_time
+        cmd_search.first <= item_time && item_time < cmd_search.last
+      elsif cmd_search.is_a?(Regexp)
+        item_val[cmd_search]
+      elsif cmd_search == ''
+        item_val == cmd_search
+      else
+        item_val.to_s[/#{Regexp.escape(cmd_search)}/i]
+      end
+    end
+
+    def compare_check(item, node, cmd_types)
+      cmd = node[:value].first
+      cmd_val = cmd[:value]
+      cmd_type = cmd_types[cmd[:value].to_sym]
+      item_val = item[cmd_val.to_sym] || item[cmd_val.to_s]
+      search = node[:value].last
+      val = search[:value]
+      if val.is_a?(Time)
+        item_val = item_val.to_time if item_val
+      elsif search[:type] == :str && cmd_types[val.to_sym]
+        val = item[val.to_sym] || item[val.to_s]
+      end
+      args = [item_val, val]
+      return unless args.all?
+      fn = node[:nest_op].to_sym.to_proc
+      fn.call(*args.map(&:to_f))
+    end
+
+    def check(item, ast, fields, cmd_types)
+      ast.all? do |node|
+        val = node[:value]
+        case node[:nest_type]
+        when nil
+          fields.any? do |x|
+            item_val = item[x.to_sym] || item[x.to_s]
+            item_val.to_s[val] if item_val
+          end
+        when :colon
+          command_check(item, val)
+        when :compare
+          compare_check(item, node, cmd_types)
+        when :minus
+          !val.all? { |v| check(item, [v], fields, cmd_types) }
+        when :pipe
+          val.any? { |v| check(item, [v], fields, cmd_types) }
+        when :paren
+          val.all? { |v| check(item, [v], fields, cmd_types) }
+        end
+      end
+    end
+  end
+end

data/lib/command_search/backends/mongoer.rb

@@ -0,0 +1,88 @@
+module CommandSearch
+  module Mongoer
+    module_function
+
+    def build_search(node, fields, cmd_fields)
+      val = node[:value]
+      forms = fields.map do |field|
+        type = cmd_fields[field.to_sym]
+        if type == Numeric
+          { field => node[:number_value] }
+        else
+          { field => val }
+        end
+      end
+      return forms if forms.count < 2
+      { '$or' => forms }
+    end
+
+    def build_command(node)
+      (field_node, search_node) = node[:value]
+      key = field_node[:value]
+      val = search_node[:value]
+      search_type = search_node[:type]
+      search_type = Boolean if search_type == :existence && val == true
+      if search_type == Boolean
+        # These queries can return true for empty arrays.
+        val = [
+          { key => { '$exists' => true } },
+          { key => { '$ne' => !val } }
+        ]
+        key = '$and'
+      elsif search_type == :existence
+        val = { '$exists' => false }
+      elsif search_type == Time
+        return [{ CommandSearchNilTime: true }, { CommandSearchNilTime: false }] unless val
+        return [
+          { key => { '$gte' => val[0] } },
+          { key => { '$lt' => val[1] } }
+        ]
+      end
+      { key => val }
+    end
+
+    def build_compare(node, cmd_fields)
+      op_map = { '<' => '$lt', '>' => '$gt', '<=' => '$lte', '>=' => '$gte' }
+      op = op_map[node[:nest_op]]
+      key = node[:value][0][:value]
+      val = node[:value][1][:value]
+      if val.class == String && cmd_fields[val.to_sym]
+        val = '$' + val
+        key = '$' + key
+        val = [key, val]
+        key = '$expr'
+      end
+      { key => { op => val } }
+    end
+
+    def build_searches!(ast, fields, cmd_fields)
+      mongo_types = { paren: '$and', pipe: '$or', minus: '$nor' }
+      ast.map! do |node|
+        type = node[:nest_type]
+        if type == :colon
+          build_command(node)
+        elsif type == :compare
+          build_compare(node, cmd_fields)
+        elsif key = mongo_types[type]
+          build_searches!(node[:value], fields, cmd_fields)
+          val = node[:value]
+          if key == '$nor' && val.count > 1
+            next { key => [{ '$and' => val }] }
+          end
+          val.map! { |x| x['$or'] || x }.flatten! unless key == '$and'
+          { key => val }
+        else
+          build_search(node, fields, cmd_fields)
+        end
+      end
+      ast.flatten!
+    end
+
+    def build_query(ast, fields, cmd_fields)
+      build_searches!(ast, fields, cmd_fields)
+      return {} if ast == []
+      return ast.first if ast.count == 1
+      { '$and' => ast }
+    end
+  end
+end

data/lib/command_search/lexer.rb

@@ -9,7 +9,7 @@ module CommandSearch
         match = nil
         case input[i..-1]
         when /\A\s+/
-          type = :space
+          next i += Regexp.last_match[0].length
         when /\A"(.*?)"/
           match = Regexp.last_match[1]
           type = :quoted_str

data/lib/command_search/normalizer.rb

@@ -0,0 +1,121 @@
+require('chronic')
+
+module CommandSearch
+  module Normalizer
+    module_function
+
+    def cast_bool(type, node)
+      if type == Boolean
+        node[:type] = Boolean
+        node[:value] = !!node[:value][0][/t/i]
+        return
+      end
+      return unless type.is_a?(Array) && type.include?(:allow_existence_boolean)
+      return unless node[:type] == :str && node[:value][/\Atrue\Z|\Afalse\Z/i]
+      node[:type] = :existence
+      node[:value] = !!node[:value][0][/t/i]
+    end
+
+    def cast_time(node)
+      search_node = node[:value][1]
+      search_node[:type] = Time
+      str = search_node[:value]
+      if str == str.to_i.to_s
+        search_node[:value] = [Time.new(str), Time.new(str.to_i + 1)]
+      else
+        time_str = str.tr('._-', ' ')
+        times = Chronic.parse(time_str, { guess: nil })
+        times ||= Chronic.parse(str, { guess: nil })
+        if times
+          search_node[:value] = [times.first, times.last]
+        else
+          search_node[:value] = nil
+          return
+        end
+      end
+      return unless node[:nest_type] == :compare
+      op = node[:nest_op]
+      if op == '<' || op == '>='
+        search_node[:value] = search_node[:value].first
+      else
+        search_node[:value] = search_node[:value].last
+        search_node[:value] -= 1
+      end
+    end
+
+    def cast_regex(node)
+      type = node[:type]
+      return unless type == :str || type == :quoted_str || type == :number
+      raw = node[:value]
+      str = Regexp.escape(raw)
+      return node[:value] = /#{str}/i unless type == :quoted_str
+      return node[:value] = '' if raw == ''
+      return node[:value] = /\b#{str}\b/ unless raw[/(^\W)|(\W$)/]
+      border_a = '(^|\s|[^:+\w])'
+      border_b = '($|\s|[^:+\w])'
+      node[:value] = Regexp.new(border_a + str + border_b)
+    end
+
+    def flip_operator!(node, cmd_fields)
+      val = node[:value]
+      return if cmd_fields[val[0][:value].to_sym]
+      return unless cmd_fields[val[1][:value].to_sym]
+      flip_ops = { '<' => '>', '>' => '<', '<=' => '>=', '>=' => '<=' }
+      node[:nest_op] = flip_ops[node[:nest_op]]
+      node[:value].reverse!
+    end
+
+    def dealias_key(key, cmd_fields)
+      key = cmd_fields[key.to_sym] while cmd_fields[key.to_sym].is_a?(Symbol)
+      key.to_s
+    end
+
+    def dealias!(ast, cmd_fields)
+      ast.map! do |node|
+        nest = node[:nest_type]
+        unless nest
+          node[:number_value] = node[:value] if node[:type] == :number
+          cast_regex(node)
+          next node
+        end
+        unless nest == :colon || nest == :compare
+          dealias!(node[:value], cmd_fields)
+          next node
+        end
+        flip_operator!(node, cmd_fields) if nest == :compare
+        (key_node, search_node) = node[:value]
+        new_key = dealias_key(key_node[:value], cmd_fields)
+        type = cmd_fields[new_key.to_sym]
+        node[:value][0][:value] = new_key
+        if type
+          cast_bool(type, search_node)
+          type = (type - [:allow_existence_boolean]).first if type.is_a?(Array)
+          cast_time(node) if [Time, Date, DateTime].include?(type)
+          cast_regex(search_node) if type == String
+          next node
+        end
+        str_values = "#{new_key}#{node[:nest_op]}#{search_node[:value]}"
+        node = { type: :str, value: str_values }
+        cast_regex(node)
+        node
+      end
+    end
+
+    def normalize!(ast, cmd_fields)
+      dealias!(ast, cmd_fields)
+      clean = {}
+      cmd_fields.each do |k, v|
+        next if v.is_a?(Symbol)
+        if v.is_a?(Array)
+          clean[k] = (v - [:allow_existence_boolean]).first
+          next
+        end
+        v = Numeric if v == Integer
+        v = Time if v == Date
+        v = Time if v == DateTime
+        next clean[k] = v
+      end
+      clean
+    end
+  end
+end

data/lib/command_search/optimizer.rb

@@ -2,60 +2,33 @@ module CommandSearch
   module Optimizer
     module_function
 
-    def ands_and_ors!(ast)
+    def denest!(ast, parent_type = :paren)
       ast.map! do |node|
-        next node unless node[:nest_type] == :paren || node[:nest_type] == :pipe
-        ands_and_ors!(node[:value])
-        next node[:value].first if node[:value].length < 2
-        next node unless node[:nest_type] == :pipe
-        node[:value].map! do |kid|
-          next kid[:value] if kid[:nest_type] == :pipe
-          kid
-        end
-        node[:value].flatten!
-        node[:value].uniq!
-        node
-      end
-    end
-
-    def negate_negate!(ast)
-      ast.map! do |node|
-        next node unless node[:nest_type]
-        negate_negate!(node[:value])
-        next [] if node[:value] == []
+        next [] if node[:type] == :quoted_str && node[:value] == '' && [:paren, :pipe, :minus].include?(parent_type)
         type = node[:nest_type]
-        child_type = node[:value].first[:nest_type]
-        next node unless type == :minus && child_type == :minus
-        node[:value].first[:value]
-      end
-      ast.flatten!
-    end
-
-    def denest_parens!(ast, parent_type = :root)
-      ast.map! do |node|
-        next node unless node[:nest_type]
-        denest_parens!(node[:value], node[:nest_type])
-        # valid_self && (valid_parent || valid_child)
-        if node[:nest_type] == :paren && (parent_type != :pipe || node[:value].count < 2)
-          next node[:value]
+        next node unless type
+        next node unless type == :paren || type == :pipe || type == :minus
+        denest!(node[:value], type)
+        next [] if node[:value] == []
+        if type == :minus
+          only_child = node[:value].count == 1
+          child = node[:value].first
+          next child[:value] if only_child && child[:nest_type] == :minus
+          next node
         end
+        next node[:value] if node[:value].count == 1
+        next node[:value] if type == parent_type
+        next node[:value] if type == :paren && parent_type == :minus
+        next node if type == :paren
+        denest!(node[:value], type) # type == :pipe, parent_type == :paren
+        node[:value].uniq!
         node
       end
       ast.flatten!
     end
 
-    def remove_empty_strings!(ast)
-      ast.reject! do |node|
-        remove_empty_strings!(node[:value]) if [:paren, :pipe, :minus].include?(node[:nest_type])
-        node[:type] == :quoted_str && node[:value] == ''
-      end
-    end
-
-    def optimize(ast)
-      denest_parens!(ast)
-      remove_empty_strings!(ast)
-      negate_negate!(ast)
-      ands_and_ors!(ast)
+    def optimize!(ast)
+      denest!(ast)
       ast.uniq!
       ast
     end

data/lib/command_search/parser.rb

@@ -47,7 +47,7 @@ module CommandSearch
         left = input[i][:type]
         right = input[i + 2][:type]
         if types.include?(left) && types.include?(right)
-          input.insert(i + 1, input[i + 1])
+          input.insert(i + 1, input[i + 1].clone())
         end
         i += 1
       end
@@ -83,7 +83,6 @@ module CommandSearch
         input[i - 1..i] = merge_strs(input[i - 1..i], [1, 0]) if i > 0
       end
 
-      input.select! { |x| x[:type] != :space }
       input[-1][:type] = :str if input[-1] && input[-1][:type] == :minus
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: command_search
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.0
 platform: ruby
 authors:
 - zumbalogy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-14 00:00:00.000000000 Z
+date: 2019-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chronic
@@ -32,10 +32,10 @@ extra_rdoc_files: []
 files:
 - lib/command_search.rb
 - lib/command_search/aliaser.rb
-- lib/command_search/command_dealiaser.rb
+- lib/command_search/backends/memory.rb
+- lib/command_search/backends/mongoer.rb
 - lib/command_search/lexer.rb
-- lib/command_search/memory.rb
-- lib/command_search/mongoer.rb
+- lib/command_search/normalizer.rb
 - lib/command_search/optimizer.rb
 - lib/command_search/parser.rb
 homepage: https://github.com/zumbalogy/command_search

data/lib/command_search/command_dealiaser.rb

@@ -1,48 +0,0 @@
-module CommandSearch
-  module CommandDealiaser
-    module_function
-
-    def dealias_key(key, aliases)
-      key = aliases[key.to_sym] while aliases[key.to_sym].is_a?(Symbol)
-      key.to_s
-    end
-
-    def dealias_values((key_node, search_node), aliases)
-      new_key = dealias_key(key_node[:value], aliases)
-      key_node[:value] = new_key
-      [key_node, search_node]
-    end
-
-    def unnest_unaliased(node, aliases)
-      type = node[:nest_type]
-      if type == :colon
-        val = node[:value][0][:value].to_sym
-        return node if aliases[val]
-      elsif type == :compare
-        return node if node[:value].any? { |child| aliases[child[:value].to_sym] }
-      end
-      values = node[:value].map { |x| x[:value] }
-      str_values = values.join(node[:nest_op])
-      { type: :str, value: str_values }
-    end
-
-    def dealias(ast, aliases)
-      ast.map! do |x|
-        next x unless x[:nest_type]
-        dealias(x[:value], aliases)
-        next x unless [:colon, :compare].include?(x[:nest_type])
-        x[:value] = dealias_values(x[:value], aliases)
-        x
-      end
-    end
-
-    def decompose_unaliasable(ast, aliases)
-      ast.map! do |x|
-        next x unless x[:nest_type]
-        decompose_unaliasable(x[:value], aliases)
-        next x unless [:colon, :compare].include?(x[:nest_type])
-        unnest_unaliased(x, aliases)
-      end
-    end
-  end
-end

data/lib/command_search/memory.rb

@@ -1,125 +0,0 @@
-require('chronic')
-
-module CommandSearch
-  module Memory
-    module_function
-
-    def command_check(item, val, command_types)
-      cmd = val[0][:value].to_sym
-      cmd_search = val[1][:value]
-      raw_cmd_type = [command_types[cmd]].flatten
-      allow_existence_boolean = raw_cmd_type.include?(:allow_existence_boolean)
-      cmd_type = (raw_cmd_type - [:allow_existence_boolean]).first
-      if cmd_type == Boolean
-        if cmd_search[/true/i]
-          item[cmd]
-        else
-          item[cmd] == false
-        end
-      elsif allow_existence_boolean && (cmd_search[/true/i] || cmd_search[/false/i])
-        if cmd_search[/true/i]
-          item[cmd]
-        else
-          item[cmd] == nil
-        end
-      elsif !item.key?(cmd)
-        return false
-      elsif [Date, Time, DateTime].include?(cmd_type)
-        item_time = item[cmd].to_time
-        if cmd_search == cmd_search.to_i.to_s
-          Time.new(cmd_search) <= item_time && item_time < Time.new(cmd_search.to_i + 1)
-        else
-          time_str = cmd_search.gsub(/[\._-]/, ' ')
-          input_times = Chronic.parse(time_str, { guess: nil }) || Chronic.parse(cmd_search, { guess: nil })
-          input_times.first <= item_time && item_time < input_times.last
-        end
-      elsif val[1][:type] == :quoted_str
-        regex = /\b#{Regexp.escape(cmd_search)}\b/
-        regex = /\A\Z/ if cmd_search == ''
-        if cmd_search[/(^\W)|(\W$)/]
-          head_border = '(?<=^|[^:+\w])'
-          tail_border = '(?=$|[^:+\w])'
-          regex = Regexp.new(head_border + Regexp.escape(cmd_search) + tail_border)
-        end
-        item[cmd][regex]
-      else
-        item[cmd].to_s[/#{Regexp.escape(cmd_search)}/i]
-      end
-    end
-
-    def compare_check(item, node, command_types)
-      children = node[:value]
-      cmd = children.find { |c| command_types[c[:value].to_sym] }
-      raw_cmd_type = [command_types[cmd[:value].to_sym]].flatten
-      cmd_type = (raw_cmd_type - [:allow_existence_boolean]).first
-
-      args = children.map do |child|
-        child_val = child[:value]
-        item_val = item[child_val.to_s] || item[child_val.to_sym]
-        item_val ||= child_val unless child == cmd
-        next unless item_val
-        next item_val.to_time if child == cmd && [Date, Time, DateTime].include?(cmd_type)
-        next item_val if child == cmd
-        if [Date, Time, DateTime].include?(cmd_type)
-          date_start_map = {
-            '<' => :start,
-            '>' => :end,
-            '<=' => :end,
-            '>=' => :start
-          }
-          date_pick = date_start_map[node[:nest_op]]
-          time_str = item_val.gsub(/[\._-]/, ' ')
-          next Time.new(time_str) if time_str == time_str.to_i.to_s
-
-          date = Chronic.parse(time_str, { guess: nil }) || Chronic.parse(item_val, { guess: nil })
-          if date_pick == :start
-            date.first
-          else
-            date.last
-          end
-        else
-          item_val
-        end
-      end
-      return unless args.all?
-      fn = node[:nest_op].to_sym.to_proc
-      fn.call(*args.map(&:to_f))
-    end
-
-    def check(item, ast, fields, command_types)
-      field_vals = fields.map { |x| item[x] || item[x.to_s] || item[x.to_sym] }.compact
-      ast_array = ast.is_a?(Array) ? ast : [ast]
-      ast_array.all? do |node|
-        val = node[:value]
-        case node[:nest_type]
-        when nil
-          if node[:type] == :quoted_str
-            regex = /\b#{Regexp.escape(val)}\b/
-            if val[/(^\W)|(\W$)/]
-              head_border = '(?<=^|[^:+\w])'
-              tail_border = '(?=$|[^:+\w])'
-              regex = Regexp.new(head_border + Regexp.escape(val) + tail_border)
-            end
-            field_vals.any? { |x| x.to_s[regex] }
-          else
-            field_vals.any? { |x| x.to_s[/#{Regexp.escape(val)}/i] }
-          end
-        when :colon
-          command_check(item, val, command_types)
-        when :compare
-          compare_check(item, node, command_types)
-        when :pipe
-          val.any? { |v| check(item, v, fields, command_types) }
-        when :minus
-          !val.all? { |v| check(item, v, fields, command_types) }
-        when :paren
-          val.all? { |v| check(item, v, fields, command_types) }
-        end
-      end
-    end
-
-    def build_query(ast, fields, command_types = {})
-      proc { |x| check(x, ast, fields, command_types) }
-    end
-  end
-end

data/lib/command_search/mongoer.rb

@@ -1,229 +0,0 @@
-require('chronic')
-
-module CommandSearch
-  module Mongoer
-    module_function
-
-    def numeric_field?(field, command_types)
-      type = command_types[field.to_sym]
-      if type.is_a?(Array)
-        type = (type - [:allow_existence_boolean]).first
-      end
-      [Numeric, Integer].include?(type)
-    end
-
-    def build_str_regex(raw, type)
-      str = Regexp.escape(raw)
-      return /#{str}/i unless type == :quoted_str
-      return '' if raw == ''
-      return /\b#{str}\b/ unless raw[/(^\W)|(\W$)/]
-      border_a = '(^|\s|[^:+\w])'
-      border_b = '($|\s|[^:+\w])'
-      Regexp.new(border_a + str + border_b)
-    end
-
-    def build_search(ast_node, fields, command_types)
-      str = ast_node[:value] || ''
-      fields = [fields] unless fields.is_a?(Array)
-      regex = build_str_regex(str, ast_node[:type])
-
-      forms = fields.map do |field|
-        if numeric_field?(field, command_types)
-          { field => str }
-        else
-          { field => regex }
-        end
-      end
-      return forms if forms.count < 2
-      { '$or' => forms }
-    end
-
-    def is_bool_str?(str, search_type)
-      search_type != :quoted_str && str[/\Atrue\Z|\Afalse\Z/i]
-    end
-
-    def make_boolean(str)
-      str[0] == 't'
-    end
-
-    def build_time_command(key, val)
-      time_str = val.tr('_.-', ' ')
-      if time_str == time_str.to_i.to_s
-        date_a = Time.new(time_str)
-        date_b = Time.new(time_str.to_i + 1).yesterday
-      else
-        date = Chronic.parse(time_str, guess: nil) || Chronic.parse(val, guess: nil)
-        return [{ CommandSeachDummyDate: true }, { CommandSeachDummyDate: false }] unless date
-        date_a = date.begin
-        date_b = date.end
-      end
-      [
-        { key => { '$gte' => date_a } },
-        { key => { '$lte' => date_b } }
-      ]
-    end
-
-    def build_command(ast_node, command_types)
-      (field_node, search_node) = ast_node[:value]
-      key = field_node[:value]
-      raw_type = command_types[key.to_sym]
-      type = raw_type
-
-      raw_val = search_node[:value]
-      search_type = search_node[:type]
-
-      if raw_type.is_a?(Array)
-        type = (raw_type - [:allow_existence_boolean]).first
-        is_bool = raw_type.include?(:allow_existence_boolean) && is_bool_str?(raw_val, search_type)
-      else
-        type = raw_type
-        is_bool = false
-      end
-
-      if type == Boolean
-        bool = make_boolean(raw_val)
-        val = [
-          { key => { '$exists' => true } },
-          { key => { '$ne' => !bool } }
-        ]
-        key = '$and'
-      elsif is_bool
-        # These queries return true for empty arrays.
-        bool = make_boolean(raw_val)
-        if bool
-          val = [
-            { key => { '$exists' => true } },
-            { key => { '$ne' => false } }
-          ]
-          key = '$and'
-        else
-          val = { '$exists' => false }
-        end
-      elsif type == String
-        val = build_str_regex(raw_val, search_type)
-      elsif [Numeric, Integer].include?(type)
-        val = raw_val
-      elsif [Date, Time, DateTime].include?(type)
-        return build_time_command(key, raw_val)
-      end
-      { key => val }
-    end
-
-    def build_compare(ast_node, command_types)
-      flip_ops = {
-        '<' => '>',
-        '>' => '<',
-        '<=' => '>=',
-        '>=' => '<='
-      }
-      mongo_op_map = {
-        '<' => '$lt',
-        '>' => '$gt',
-        '<=' => '$lte',
-        '>=' => '$gte'
-      }
-
-      keys = command_types.keys
-      (first_node, last_node) = ast_node[:value]
-      key = first_node[:value]
-      val = last_node[:value]
-      op = ast_node[:nest_op]
-
-      if keys.include?(val.to_sym)
-        (key, val) = [val, key]
-        op = flip_ops[op]
-      end
-
-      mongo_op = mongo_op_map[op]
-      raw_type = command_types[key.to_sym]
-
-      if raw_type.is_a?(Array)
-        type = (raw_type - [:allow_existence_boolean]).first
-      else
-        type = raw_type
-      end
-
-      if command_types[val.to_sym]
-        val = '$' + val
-        key = '$' + key
-        val = [key, val]
-        key = '$expr'
-      elsif [Date, Time, DateTime].include?(type)
-        # foo <  day | day.start
-        # foo <= day | day.end
-        # foo >  day | day.end
-        # foo >= day | day.start
-        date_start_map = {
-          '<' => :start,
-          '>' => :end,
-          '<=' => :end,
-          '>=' => :start
-        }
-        date_pick = date_start_map[op]
-        time_str = val.tr('_.-', ' ')
-
-        if time_str == time_str.to_i.to_s
-          date = [Time.new(time_str), Time.new(time_str.to_i + 1).yesterday]
-        else
-          date = Chronic.parse(time_str, guess: nil) || Chronic.parse(val, guess: nil)
-        end
-
-        date = date || []
-
-        if date_pick == :start
-          val = date.first
-        elsif date_pick == :end
-          val = date.last
-        end
-      end
-      { key => { mongo_op => val } }
-    end
-
-    def build_searches!(ast, fields, command_types)
-      ast.map! do |x|
-        type = x[:nest_type]
-        if type == :colon
-          build_command(x, command_types)
-        elsif type == :compare
-          build_compare(x, command_types)
-        elsif [:paren, :pipe, :minus].include?(type)
-          build_searches!(x[:value], fields, command_types)
-          x
-        else
-          build_search(x, fields, command_types)
-        end
-      end
-      ast.flatten!
-    end
-
-    def build_tree!(ast)
-      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
-          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
-      build_searches!(out, fields, command_types)
-      build_tree!(out)
-      out = {} if out == []
-      out = out.first if out.count == 1
-      out = { '$and' => out } if out.count > 1
-      out
-    end
-  end
-end