command_search 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4560d75eabd25ff56808df06ab6b72d97813fbd75909739d15bfa2e13055557
-  data.tar.gz: 8c48236dd477f98450076128b7737121fabb16398c123e3c567f049bd68cadbf
+  metadata.gz: fa471a870d21295459efa58aa18e3777752841dc0cfec3033a6423996ed2d98c
+  data.tar.gz: 37a0b72e6cb764c90fd14eb44b0a1c096d4e6c6e2756a4715db3e02471aa6889
 SHA512:
-  metadata.gz: b0abdf98f95abba34b3a27d8f805f5183b1089e7291dad6b7f3a67e6cdb8a2413dad6813cf06e7118b733b44132428d79c89545739184022f3fc6d6222e60f8d
-  data.tar.gz: 836f1b245c14396850259c7e326e4ed1451bfcda6df07a594162ed4bbd1725abdf4a4a46c90c75c23eeb3b3a0ed242e7caa02cded714437acc1cc9ce65a63781
+  metadata.gz: fe02049b5e6eec1b62ffa6d030a747312b661f4db05befb66f5e3585bf0b5b679f65c10c7ba3348a19de97ecdb0d4f9f19b2e5466b75bd4604658b66021c6fe0
+  data.tar.gz: a5e0fa90644d5c7dd3346e1b9c7e43ef04c6e652f9f293ac59b468a2667bb388be8614854680612b62cda2812179fd800ee45a9e4229c7d4774760facd2b0b79

data/lib/command_search.rb

@@ -12,23 +12,22 @@ class Boolean; end
 module CommandSearch
   module_function
 
-  def search(source, query, options = {})
+  def search(source, query, options)
     aliases = options[:aliases] || {}
-    fields = options[:fields] || []
-    command_fields = options[:command_fields] || {}
+    fields = options[:fields] || {}
 
     aliased_query = Aliaser.alias(query, aliases)
     ast = Lexer.lex(aliased_query)
+
     Parser.parse!(ast)
     Optimizer.optimize!(ast)
-    command_fields = Normalizer.normalize!(ast, command_fields)
+    Normalizer.normalize!(ast, fields)
 
     if source.respond_to?(:mongo_client) && source.queryable
-      fields = [:__CommandSearch_dummy_key__] if fields.empty?
-      mongo_query = Mongoer.build_query(ast, fields, command_fields)
+      mongo_query = Mongoer.build_query(ast)
       return source.where(mongo_query)
     end
 
-    source.select { |x| Memory.check(x, ast, fields, command_fields) }
+    source.select { |x| Memory.check(x, ast) }
   end
 end

data/lib/command_search/aliaser.rb

@@ -3,9 +3,9 @@ module CommandSearch
     module_function
 
     def build_regex(str)
-      head_border = '(?<=^|[^:\w])'
-      tail_border = '(?=$|\W)'
-      Regexp.new(head_border + Regexp.escape(str) + tail_border, 'i')
+      head = '(?<=^|[^:\w])'
+      tail = '(?=$|\W)'
+      Regexp.new(head + Regexp.escape(str) + tail, 'i')
     end
 
     def quotes?(str, offset)
@@ -16,30 +16,21 @@ module CommandSearch
       false
     end
 
-    def alias_item(query, alias_key, alias_value)
-      return query unless alias_value.is_a?(String) || alias_value.is_a?(Proc)
-      if alias_key.is_a?(Regexp)
-        pattern = alias_key
-      elsif alias_key.is_a?(String)
-        pattern = build_regex(alias_key)
-      else
-        return query
+    def alias_item!(query, key, val)
+      if key.is_a?(String) || key.is_a?(Symbol)
+        key = build_regex(key)
       end
-      query.gsub!(pattern) do |match|
+      query.gsub!(key) do |match|
         next match if quotes?(query, Regexp.last_match.offset(0))
-        if alias_value.is_a?(String)
-          alias_value
-        elsif alias_value.is_a?(Proc)
-          alias_value.call(match).to_s
-        end
+        next val.call(match) if val.is_a?(Proc)
+        val
       end
-      query
     end
 
     def alias(query, aliases)
       return query unless aliases.any?
       out = query.dup
-      aliases.each { |(k, v)| alias_item(out, k, v) }
+      aliases.each { |(k, v)| alias_item!(out, k, v) }
       out
     end
   end

data/lib/command_search/backends/memory.rb

@@ -4,65 +4,57 @@ module CommandSearch
 
     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
+      search = val[1][:value]
+      item_val = item[cmd.to_sym] || item[cmd.to_s]
+      type = val[1][:type]
+      type = Boolean if type == :existence && search == true
+      if type == Boolean
+        !!item_val == search
+      elsif type == :existence
         item_val == nil
       elsif !item_val
         return false
-      elsif val_type == Time
+      elsif search.is_a?(Regexp)
+        item_val.to_s[search]
+        # for versions ruby 2.4.0 (2016-12-25) and up, match? is much faster
+        # item_val.to_s.match?(search)
+      elsif 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
+        search.first <= item_time && item_time < search.last
       else
-        item_val.to_s[/#{Regexp.escape(cmd_search)}/i]
+        item_val == search
       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]
+    def compare_check(item, node)
+      cmd_val = node[:value].first[:value]
       item_val = item[cmd_val.to_sym] || item[cmd_val.to_s]
-      search = node[:value].last
-      val = search[:value]
+      return unless item_val
+      val = node[:value].last[:value]
       if val.is_a?(Time)
-        item_val = item_val.to_time if item_val
-      elsif search[:type] == :str && cmd_types[val.to_sym]
+        item_val = item_val.to_time
+      elsif node[:compare_across_fields]
         val = item[val.to_sym] || item[val.to_s]
       end
-      args = [item_val, val]
-      return unless args.all?
+      return unless val
       fn = node[:nest_op].to_sym.to_proc
-      fn.call(*args.map(&:to_f))
+      fn.call(item_val.to_f, val.to_f)
     end
 
-    def check(item, ast, fields, cmd_types)
+    def check(item, ast)
       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
+        case node[:type]
         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) }
+          compare_check(item, node)
+        when :not
+          !val.all? { |v| check(item, [v]) }
+        when :or
+          val.any? { |v| check(item, [v]) }
+        when :and
+          val.all? { |v| check(item, [v]) }
         end
       end
     end

data/lib/command_search/backends/mongoer.rb

@@ -2,20 +2,6 @@ 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]
@@ -41,12 +27,12 @@ module CommandSearch
       { key => val }
     end
 
-    def build_compare(node, cmd_fields)
+    def build_compare(node)
       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]
+      if node[:compare_across_fields]
         val = '$' + val
         key = '$' + key
         val = [key, val]
@@ -55,31 +41,29 @@ module CommandSearch
       { key => { op => val } }
     end
 
-    def build_searches!(ast, fields, cmd_fields)
-      mongo_types = { paren: '$and', pipe: '$or', minus: '$nor' }
+    def build_searches!(ast)
+      mongo_types = { and: '$and', or: '$or', not: '$nor' }
       ast.map! do |node|
-        type = node[:nest_type]
+        type = node[:type]
         if type == :colon
           build_command(node)
         elsif type == :compare
-          build_compare(node, cmd_fields)
+          build_compare(node)
         elsif key = mongo_types[type]
-          build_searches!(node[:value], fields, cmd_fields)
+          build_searches!(node[:value])
           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)
+    def build_query(ast)
+      build_searches!(ast)
       return {} if ast == []
       return ast.first if ast.count == 1
       { '$and' => ast }

data/lib/command_search/lexer.rb

@@ -12,15 +12,15 @@ module CommandSearch
           next i += Regexp.last_match[0].length
         when /\A"(.*?)"/
           match = Regexp.last_match[1]
-          type = :quoted_str
+          type = :quote
         when /\A'(.*?)'/
           match = Regexp.last_match[1]
-          type = :quoted_str
+          type = :quote
         when /\A\-?\d+(\.\d+)?(?=$|[\s"':|<>()])/
           type = :number
         when /\A-/
           type = :minus
-        when /\A[^\s:"|<>()]+/
+        when /\A[^\s:|<>()]+/
           type = :str
         when /\A\|+/
           type = :pipe
@@ -30,10 +30,8 @@ module CommandSearch
           type = :colon
         when /\A[<>]=?/
           type = :compare
-        when /\A./
-          type = :str
         end
-        match = match || Regexp.last_match[0]
+        match ||= Regexp.last_match[0]
         out.push(type: type, value: match)
         i += Regexp.last_match[0].length
       end

data/lib/command_search/normalizer.rb

@@ -4,19 +4,21 @@ module CommandSearch
   module Normalizer
     module_function
 
-    def cast_bool(type, node)
+    def cast_bool!(field, node)
+      type = field.is_a?(Hash) ? field[:type] : field
       if type == Boolean
+        return if field.is_a?(Hash) && field[:general_search] && !node[:value][/\Atrue\Z|\Afalse\Z/i]
         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 field.is_a?(Hash) && field[: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)
+    def cast_time!(node)
       search_node = node[:value][1]
       search_node[:type] = Time
       str = search_node[:value]
@@ -33,7 +35,7 @@ module CommandSearch
           return
         end
       end
-      return unless node[:nest_type] == :compare
+      return unless node[:type] == :compare
       op = node[:nest_op]
       if op == '<' || op == '>='
         search_node[:value] = search_node[:value].first
@@ -43,79 +45,94 @@ module CommandSearch
       end
     end
 
-    def cast_regex(node)
+    def cast_regex!(node)
       type = node[:type]
-      return unless type == :str || type == :quoted_str || type == :number
       raw = node[:value]
+      return unless raw.is_a?(String)
+      return if 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$)/]
+      return node[:value] = /#{str}/i unless type == :quote
+      return node[:value] = /\b#{str}\b/ unless raw[/(\A\W)|(\W\Z)/]
       border_a = '(^|\s|[^:+\w])'
       border_b = '($|\s|[^:+\w])'
       node[:value] = Regexp.new(border_a + str + border_b)
     end
 
-    def flip_operator!(node, cmd_fields)
+    def cast_numeric!(node)
+      return unless node[:type] == :number
+      node[:value] = node[:value].to_f
+    end
+
+    def clean_comparison!(node, fields)
       val = node[:value]
-      return if cmd_fields[val[0][:value].to_sym]
-      return unless cmd_fields[val[1][:value].to_sym]
+      return unless fields[val[1][:value].to_sym]
+      if fields[val[0][:value].to_sym]
+        node[:compare_across_fields] = true
+        return
+      end
       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
+    def dealias_key(key, fields)
+      key = fields[key.to_sym] while fields[key.to_sym].is_a?(Symbol)
+      key
+    end
+
+    def split_general_fields(node, fields)
+      general_fields = fields.select { |k, v| v.is_a?(Hash) && v[:general_search] }.keys
+      general_fields = ['__CommandSearch_dummy_key__'] if general_fields.empty?
+      new_val = general_fields.map! do |field|
+        {
+          type: :colon,
+          value: [
+            { value: field.to_s },
+            { value: node[:value], type: node[:type] }
+          ]
+        }
+      end
+      return new_val.first if new_val.count < 2
+      { type: :or, value: new_val }
+    end
+
+    def type_cast!(node, fields)
+      (key_node, search_node) = node[:value]
+      key = key_node[:value]
+      field = fields[key.to_sym] || fields[key.to_s]
+      return unless field
+      type = field.is_a?(Class) ? field : field[:type]
+      cast_bool!(field, search_node)
+      return cast_time!(node) if [Time, Date, DateTime].include?(type)
+      return cast_numeric!(search_node) if [Integer, Numeric].include?(type)
+      cast_regex!(search_node)
     end
 
-    def dealias!(ast, cmd_fields)
+    def normalize!(ast, fields)
       ast.map! do |node|
-        nest = node[:nest_type]
-        unless nest
-          node[:number_value] = node[:value] if node[:type] == :number
-          cast_regex(node)
+        if node[:type] == :and || node[:type] == :or || node[:type] == :not
+          normalize!(node[:value], fields)
           next node
         end
-        unless nest == :colon || nest == :compare
-          dealias!(node[:value], cmd_fields)
-          next node
+        if node[:type] == :colon || node[:type] == :compare
+          clean_comparison!(node, fields) if node[:type] == :compare
+          key = dealias_key(node[:value][0][:value], fields)
+          node[:value][0][:value] = key.to_s
+          unless fields[key.to_sym] || fields[key.to_s]
+            str_values = "#{key}#{node[:nest_op]}#{node[:value][1][:value]}"
+            node = { type: :str, value: str_values }
+          end
         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
+        if node[:type] == :str || node[:type] == :quote || node[:type] == :number
+          node = split_general_fields(node, fields)
         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
+        if node[:type] == :or
+          node[:value].each { |x| type_cast!(x, fields) }
+        else
+          type_cast!(node, fields)
         end
-        v = Numeric if v == Integer
-        v = Time if v == Date
-        v = Time if v == DateTime
-        next clean[k] = v
+        node
       end
-      clean
     end
   end
 end

data/lib/command_search/optimizer.rb

@@ -2,26 +2,25 @@ module CommandSearch
   module Optimizer
     module_function
 
-    def denest!(ast, parent_type = :paren)
+    def denest!(ast, parent_type = :and)
       ast.map! do |node|
-        next [] if node[:type] == :quoted_str && node[:value] == '' && [:paren, :pipe, :minus].include?(parent_type)
-        type = node[:nest_type]
-        next node unless type
-        next node unless type == :paren || type == :pipe || type == :minus
+        type = node[:type]
+        next node unless type == :and || type == :or || type == :not
         denest!(node[:value], type)
         next [] if node[:value] == []
-        if type == :minus
+        if type == :not
           only_child = node[:value].count == 1
           child = node[:value].first
-          next child[:value] if only_child && child[:nest_type] == :minus
+          next child[:value] if only_child && child[:type] == :not
           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
+        next node[:value] if type == :and && parent_type == :not
+        next node if type == :and
+        denest!(node[:value], type) # type == :or, parent_type == :and
         node[:value].uniq!
+        next node[:value] if node[:value].count == 1
         node
       end
       ast.flatten!

data/lib/command_search/parser.rb

@@ -9,39 +9,71 @@ module CommandSearch
         next i += 1 unless input[i][:type] == :paren
         if input[i][:value] == '('
           opening_idxs.push(i)
-        elsif opening = opening_idxs.pop()
-          val = input[(opening + 1)..(i - 1)]
-          input[opening..i] = { type: :nest, nest_type: :paren, value: val }
-          i -= (val.length + 1)
+          input.delete_at(i)
+          next
         end
-        i += 1
+        input.delete_at(i)
+        opening = opening_idxs.pop()
+        next unless opening
+        val = input.slice(opening, i - opening)
+        if val.count > 1
+          input[opening..(i - 1)] = { type: :and, value: val }
+          i -= val.length
+          next
+        elsif val.count == 1
+          input[opening] = val.first
+        end
+      end
+    end
+
+    def cluster_cmds!(input)
+      i = 1
+      while i < input.length - 1
+        type = input[i][:type]
+        next i += 1 unless type == :colon || type == :compare
+        input[(i - 1)..(i + 1)] = {
+          type: type,
+          nest_op: input[i][:value],
+          value: [input[i - 1], input[i + 1]]
+        }
       end
     end
 
-    def cluster!(type, input, cluster_type = :binary)
-      binary = (cluster_type == :binary)
-      i = input.length - 1
-      while i >= 0
-        if input[i][:type] == type
-          val = [input[i + 1]]
-          val.compact!
-          val.unshift(input[i - 1]) if binary && i > 0
-          front_offset = 0
-          front_offset = 1 if binary && i > 0
-          input[(i - front_offset)..(i + 1)] = {
-            type: :nest,
-            nest_type: type,
-            nest_op: input[i][:value],
-            value: val
-          }
-          i -= 1 if binary
+    def cluster_or!(input)
+      i = 0
+      while i < input.length
+        type = input[i][:type]
+        cluster_or!(input[i][:value]) if type == :and || type == :not
+        next i += 1 unless type == :pipe
+        if i == 0 || i == input.length - 1
+          input.delete_at(i)
+          next
         end
-        cluster!(type, input[i][:value], cluster_type) if input[i][:type] == :nest
+        val = [input[i - 1], input[i + 1]]
+        cluster_or!(val)
+        input[(i - 1)..(i + 1)] = { type: :or, value: val }
+      end
+    end
+
+    def cluster_not!(input)
+      i = input.length
+      while i > 0
         i -= 1
+        type = input[i][:type]
+        cluster_not!(input[i][:value]) if type == :and
+        next unless type == :minus
+        if i == input.length - 1
+          input.delete_at(i)
+          next
+        end
+        input[i..(i + 1)] = {
+          type: :not,
+          value: [input[i + 1]]
+        }
       end
     end
 
-    def unchain!(types, input)
+    def unchain!(input, types)
       i = 0
       while i < input.length - 2
         left = input[i][:type]
@@ -64,41 +96,32 @@ module CommandSearch
     end
 
     def clean_ununusable!(input)
-      i = 0
+      i = 1
       while i < input.length
         next i += 1 unless input[i][:type] == :minus
-        next i += 1 unless i > 0 && [:compare, :colon].include?(input[i - 1][:type])
+        next i += 1 unless [:compare, :colon].include?(input[i - 1][:type])
         input[i..i + 1] = merge_strs(input[i..i + 1], [0, 1])
       end
-
       i = 0
       while i < input.length
         next i += 1 if ![:compare, :colon].include?(input[i][:type])
         next i += 1 if i > 0 &&
           (i < input.count - 1) &&
-          [:str, :number, :quoted_str].include?(input[i - 1][:type]) &&
-          [:str, :number, :quoted_str].include?(input[i + 1][:type])
+          [:str, :number, :quote].include?(input[i - 1][:type]) &&
+          [:str, :number, :quote].include?(input[i + 1][:type])
 
         input[i..i + 1] = merge_strs(input[i..i + 1], [0, 1])
         input[i - 1..i] = merge_strs(input[i - 1..i], [1, 0]) if i > 0
       end
-
-      input[-1][:type] = :str if input[-1] && input[-1][:type] == :minus
-    end
-
-    def clean_ununused!(input)
-      input.reject! { |x| x[:type] == :paren && x[:value].is_a?(String) }
     end
 
     def parse!(input)
       clean_ununusable!(input)
-      unchain!([:colon, :compare], input)
+      unchain!(input, [:colon, :compare])
+      cluster_cmds!(input)
       group_parens!(input)
-      cluster!(:colon, input)
-      cluster!(:compare, input)
-      cluster!(:minus, input, :prefix)
-      cluster!(:pipe, input)
-      clean_ununused!(input)
+      cluster_not!(input)
+      cluster_or!(input)
       input
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: command_search
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - zumbalogy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-15 00:00:00.000000000 Z
+date: 2019-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chronic
@@ -57,7 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Let users query collections with ease.