command_search 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ab34234037969a83820730a8a209e1fe0ca29ed9a2b34f1f1c3f0a72b570b5c
-  data.tar.gz: f3c4af7b842ae0a59057a2d700bb9c39b739c96fe18248377deecdc38c70aede
+  metadata.gz: 93226578c66261e1923eeb6f56647b3eed274b3fe0dad3e8f016780c34e46831
+  data.tar.gz: 5d73e80d4b7f8fbca8febe5dc548332d48cd25f46b7611fae6c075268fdda5b0
 SHA512:
-  metadata.gz: d1e7ffc036d37d54217a78184a2c18705ad85529cad90e75851c6512d10a0214d22d083da7cf504eed6257bc28576c885a56dd383bc4e37cb39919ac1e8e665d
-  data.tar.gz: d4ce49e9747f21e06ced4884b4a72f03c6c335ab9d20e91f7e6ebd985a3a9cbca11dc0cacf1422d0ced8f4d322b9b48f95327099769030fa820eade6da4f5d7c
+  metadata.gz: a25f5ac8e3b4ba433df88abc38551162532ba7e04e47744e44a0ba7dd107a95471490d0506e98746f1344a259f94a8b2ff229f3468a5078ad4ef97158901b948
+  data.tar.gz: b14a8926f623e7b1ca05e51e5c0fbf1a754012a4e84284166e1fbc29b8894bf47b2fd58841d397575c1859dab46f722a21e0317afff482ec2da40302faddcf19

data/lib/command_search.rb

@@ -18,7 +18,7 @@ module CommandSearch
 
     aliased_query = Aliaser.alias(query, aliases)
     tokens = Lexer.lex(aliased_query)
-    parsed = Parser.parse(tokens)
+    parsed = Parser.parse!(tokens)
     dealiased = CommandDealiaser.dealias(parsed, command_fields)
     cleaned = CommandDealiaser.decompose_unaliasable(dealiased, command_fields)
     opted = Optimizer.optimize(cleaned)

data/lib/command_search/aliaser.rb

@@ -8,32 +8,34 @@ module CommandSearch
       Regexp.new(head_border + Regexp.escape(str) + tail_border, 'i')
     end
 
-    def opens_quote?(str)
-      while str[/".*"/] || str[/'.*'/]
-        mark = str[/["']/]
-        str.sub(/#{mark}.*#{mark}/, '')
-      end
-      str[/"/] || str[/\B'/]
+    def quotes?(head, tail)
+      return true if head.count("'").odd? && tail.count("'").odd?
+      return true if head.count('"').odd? && tail.count('"').odd?
+      false
     end
 
     def alias_item(query, alias_key, alias_value)
       if alias_key.is_a?(Regexp)
         pattern = alias_key
+      elsif alias_key.is_a?(String)
+        pattern = build_regex(alias_key)
       else
-        pattern = build_regex(alias_key.to_s)
+        return query
       end
       current_match = query[pattern]
       return query unless current_match
       offset = Regexp.last_match.offset(0)
       head = query[0...offset.first]
       tail = alias_item(query[offset.last..-1], alias_key, alias_value)
-      if opens_quote?(head)
+      if quotes?(head, tail)
         replacement = current_match
       else
         if alias_value.is_a?(String)
           replacement = alias_value
         elsif alias_value.is_a?(Proc)
           replacement = alias_value.call(current_match).to_s
+        else
+          return query
         end
       end
       head + replacement + tail

data/lib/command_search/command_dealiaser.rb

@@ -23,9 +23,9 @@ module CommandSearch
     end
 
     def dealias(ast, aliases)
-      ast.flat_map do |x|
+      ast.map! do |x|
         next x unless x[:nest_type]
-        x[:value] = dealias(x[:value], aliases)
+        dealias(x[:value], aliases)
         next x unless [:colon, :compare].include?(x[:nest_type])
         x[:value] = dealias_values(x[:value], aliases)
         x
@@ -33,9 +33,9 @@ module CommandSearch
     end
 
     def decompose_unaliasable(ast, aliases)
-      ast.flat_map do |x|
+      ast.map! do |x|
         next x unless x[:nest_type]
-        x[:value] = decompose_unaliasable(x[:value], aliases)
+        decompose_unaliasable(x[:value], aliases)
         next x unless [:colon, :compare].include?(x[:nest_type])
         unnest_unaliased(x, aliases)
       end

data/lib/command_search/lexer.rb

@@ -8,29 +8,29 @@ module CommandSearch
       while i < input.length
         match = nil
         case input[i..-1]
-        when /^\s+/
+        when /\A\s+/
           type = :space
-        when /^"(.*?)"/
+        when /\A"(.*?)"/
           match = Regexp.last_match[1]
           type = :quoted_str
-        when /^'(.*?)'/
+        when /\A'(.*?)'/
           match = Regexp.last_match[1]
           type = :quoted_str
-        when /^\-?\d+(\.\d+)?(?=$|[\s"':|<>()])/
+        when /\A\-?\d+(\.\d+)?(?=$|[\s"':|<>()])/
           type = :number
-        when /^-/
+        when /\A-/
           type = :minus
-        when /^[^\s:"|<>()]+/
+        when /\A[^\s:"|<>()]+/
           type = :str
-        when /^\|+/
+        when /\A\|+/
           type = :pipe
-        when /^[()]/
+        when /\A[()]/
           type = :paren
-        when /^:/
+        when /\A:/
           type = :colon
-        when /^[<>]=?/
+        when /\A[<>]=?/
           type = :compare
-        when /^./
+        when /\A./
           type = :str
         end
         match = match || Regexp.last_match[0]

data/lib/command_search/memory.rb

@@ -10,7 +10,6 @@ module CommandSearch
       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
-      return unless cmd_type
       if cmd_type == Boolean
         if cmd_search[/true/i]
           item[cmd]
@@ -25,8 +24,6 @@ module CommandSearch
         end
       elsif !item.key?(cmd)
         return false
-      elsif val[1][:type] == :str
-        item[cmd][/#{Regexp.escape(cmd_search)}/i]
       elsif val[1][:type] == :quoted_str
         regex = /\b#{Regexp.escape(cmd_search)}\b/
         if cmd_search[/(^\W)|(\W$)/]

data/lib/command_search/mongoer.rb

@@ -5,7 +5,7 @@ module CommandSearch
     module_function
 
     def build_search(ast_node, fields)
-      str = ast_node[:value]
+      str = ast_node[:value] || ''
       fields = [fields] unless fields.is_a?(Array)
       if ast_node[:type] == :quoted_str
         regex = /\b#{Regexp.escape(str)}\b/
@@ -15,9 +15,7 @@ module CommandSearch
           regex = Regexp.new(head_border + Regexp.escape(str) + tail_border)
         end
       else
-        # TODO: This OR check is only needed due to mutable objects between subclasses of command_search,
-        # and is only needed for outside use or benchmarking.
-        regex = /#{Regexp.escape(str || '')}/i
+        regex = /#{Regexp.escape(str)}/i
       end
       if ast_node[:negate]
         forms = fields.map { |f| { f => { '$not' => regex } } }
@@ -33,17 +31,16 @@ module CommandSearch
     end
 
     def is_bool_str?(str)
-      return true if str[/^true$|^false$/i]
+      return true if str[/\Atrue\Z|\Afalse\Z/i]
       false
     end
 
     def make_boolean(str)
-      return true if str[/^true$/i]
+      return true if str[/\Atrue\Z/i]
       false
     end
 
     def build_command(ast_node, command_types)
-      # aliasing will is done before ast gets to mongoer.rb
       (field_node, search_node) = ast_node[:value]
       key = field_node[:value]
       raw_type = command_types[key.to_sym]
@@ -60,8 +57,7 @@ module CommandSearch
         type = raw_type
       end
 
-      if defined?(Boolean) && type == Boolean
-        # val = make_boolean(raw_val)
+      if type == Boolean
         bool = make_boolean(raw_val)
         bool = !bool if field_node[:negate]
         val = [
@@ -100,7 +96,7 @@ module CommandSearch
       elsif [Numeric, Integer].include?(type)
         if raw_val == raw_val.to_i.to_s
           val = raw_val.to_i
-        elsif raw_val.to_f != 0 || raw_val[/^[\.0]*0$/]
+        elsif raw_val.to_f != 0 || raw_val[/\A[\.0]*0\Z/]
           val = raw_val.to_f
         else
           val = raw_val
@@ -205,40 +201,41 @@ module CommandSearch
       { key => { mongo_op => val } }
     end
 
-    def build_searches(ast, fields, command_types)
-      ast.flat_map do |x|
+    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)
-          x[:value] = build_searches(x[:value], fields, command_types)
+          build_searches!(x[:value], fields, command_types)
           x
         else
           build_search(x, fields)
         end
       end
+      ast.flatten!
     end
 
-    def build_tree(ast)
-      ast.flat_map do |x|
+    def build_tree!(ast)
+      mongo_types = { paren: '$and', pipe: '$or', minus: '$not' }
+      ast.each do |x|
         next x unless x[:nest_type]
-        mongo_types = { paren: '$and', pipe: '$or', minus: '$not' }
+        build_tree!(x[:value])
         key = mongo_types[x[:nest_type]]
-        { key => build_tree(x[:value]) }
+        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.flat_map do |x|
-        ['$and', '$or', '$not'].map do |key|
-          next unless x[key]
-          x[key] = collapse_ors(x[key])
-        end
-        next x unless x['$or']
-        val = x['$or'].flat_map { |kid| kid['$or'] || kid }
-        { '$or' => val }
+    def collapse_ors!(ast)
+      ast.each do |x|
+        next unless x['$or']
+        x['$or'].map! { |kid| kid['$or'] || kid }.flatten!
       end
     end
 
@@ -257,12 +254,11 @@ module CommandSearch
     end
 
     def build_query(ast, fields, command_types = {})
-      # Numbers are searched as strings unless part of a compare/command
       out = ast
       out = decompose_nots(out)
-      out = build_searches(out, fields, command_types)
-      out = build_tree(out)
-      out = collapse_ors(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

data/lib/command_search/optimizer.rb

@@ -2,18 +2,16 @@ module CommandSearch
   module Optimizer
     module_function
 
-    def ands_and_ors(ast)
-      ast.uniq.map do |node|
-        next node unless node[:nest_type]
-        next node if node[:nest_type] == :compare
-        node[:value] = ands_and_ors(node[:value])
+    def ands_and_ors!(ast)
+      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
         node[:value] = node[:value].flat_map do |kid|
           next kid[:value] if kid[:nest_type] == :pipe
           kid
         end
-        if node[:nest_type] == :pipe && node[:value].length == 1
-          next node[:value].first
-        end
+        node[:value].uniq!
         node
       end
     end
@@ -23,7 +21,6 @@ module CommandSearch
         next node unless node[:nest_type]
         node[:value] = negate_negate(node[:value])
         next [] if node[:value] == []
-        next node if node[:value].count > 1
         type = node[:nest_type]
         child_type = node[:value].first[:nest_type]
         next node unless type == :minus && child_type == :minus
@@ -34,51 +31,30 @@ module CommandSearch
     def denest_parens(ast, parent_type = :root)
       ast.flat_map do |node|
         next node unless node[:nest_type]
-
         node[:value] = denest_parens(node[:value], node[:nest_type])
-
-        valid_self = node[:nest_type] == :paren
-        valid_parent = parent_type != :pipe
-        valid_child = node[:value].count < 2
-
-        next node[:value] if valid_self && valid_parent
-        next node[:value] if valid_self && valid_child
+        # valid_self && (valid_parent || valid_child)
+        if node[:nest_type] == :paren && (parent_type != :pipe || node[:value].count < 2)
+          next node[:value]
+        end
         node
       end
     end
 
-    def remove_empty_strings(ast)
-      out = ast.flat_map do |node|
-        next if node[:type] == :quoted_str && node[:value] == ''
-        next node unless node[:nest_type]
-        node[:value] = remove_empty_strings(node[:value])
-        node
+    def remove_empty_strings!(ast)
+      ast.reject! do |node|
+        remove_empty_strings!(node[:value]) if node[:nest_type]
+        node[:type] == :quoted_str && node[:value] == ''
       end
-      out.compact
     end
 
-    def optimization_pass(ast)
-      # '(a b)|(c d)' is the  only current
-      # situation where parens are needed.
-      # 'a|(b|(c|d))' can be flattened by
-      # repeated application of "ands_and_or"
-      # and "denest_parens".
+    def optimize(ast)
       out = ast
       out = denest_parens(out)
+      remove_empty_strings!(out)
       out = negate_negate(out)
-      out = ands_and_ors(out)
-      out = remove_empty_strings(out)
+      ands_and_ors!(out)
+      out.uniq!
       out
     end
-
-    def optimize(ast)
-      out_a = optimization_pass(ast)
-      out_b = optimization_pass(out_a)
-      until out_a == out_b
-        out_a = out_b
-        out_b = optimization_pass(out_b)
-      end
-      out_b
-    end
   end
 end

data/lib/command_search/parser.rb

@@ -3,7 +3,6 @@ module CommandSearch
     module_function
 
     def parens_rindex(input)
-      val_list = input.map { |x| x[:value] }
       open_i = input.rindex { |x| x[:value] == '(' && x[:type] == :paren}
       return unless open_i
       close_offset = input.drop(open_i).index { |x| x[:value] == ')' && x[:type] == :paren}
@@ -11,48 +10,41 @@ module CommandSearch
       [open_i, close_offset + open_i]
     end
 
-    def group_parens(input)
-      out = input
-      while parens_rindex(out)
-        (a, b) = parens_rindex(out)
-        val = out[(a + 1)..(b - 1)]
-        out[a..b] = { type: :nest, nest_type: :paren, value: val }
+    def group_parens!(input)
+      while parens_rindex(input)
+        (a, b) = parens_rindex(input)
+        val = input[(a + 1)..(b - 1)]
+        input[a..b] = { type: :nest, nest_type: :paren, value: val }
       end
-      out
     end
 
     def cluster!(type, input, cluster_type = :binary)
       binary = (cluster_type == :binary)
-      out = input
-      out = out[:value] while out.is_a?(Hash)
-      out.compact!
+      input.compact!
       # rindex (vs index) important for nested prefixes
-      while (i = out.rindex { |x| x[:type] == type })
-        val = [out[i + 1]]
-        val.unshift(out[i - 1]) if binary && i > 0
+      while (i = input.rindex { |x| x[:type] == type })
+        val = [input[i + 1]]
+        val.unshift(input[i - 1]) if binary && i > 0
         front_offset = 0
         front_offset = 1 if binary && i > 0
-        out[(i - front_offset)..(i + 1)] = {
+        input[(i - front_offset)..(i + 1)] = {
           type: :nest,
           nest_type: type,
-          nest_op: out[i][:value],
+          nest_op: input[i][:value],
           value: val
         }
       end
-      out.map! do |x|
-        next x unless x[:type] == :nest
-        x[:value] = cluster!(type, x[:value], cluster_type)
-        x
+      input.each do |x|
+        cluster!(type, x[:value], cluster_type) if x[:type] == :nest
       end
     end
 
     def unchain!(types, input)
       i = 0
       while i < input.length - 2
-        front = input[i][:type]
-        mid = input[i + 1][:type]
-        back = input[i + 2][:type]
-        if types.include?(front) && !types.include?(mid) && types.include?(back)
+        left = input[i][:type]
+        right = input[i + 2][:type]
+        if types.include?(left) && types.include?(right)
           input.insert(i + 1, input[i + 1])
         end
         i += 1
@@ -60,7 +52,6 @@ module CommandSearch
     end
 
     def merge_strs(input, (x, y))
-      return input if input.empty?
       if input[y] && input[y][:type] == :str
         values = input.map { |x| x[:value] }
         { type: :str, value: values.join() }
@@ -71,8 +62,6 @@ module CommandSearch
     end
 
     def clean_ununusable!(input)
-      return unless input.any?
-
       i = 0
       while i < input.length
         next i += 1 unless input[i][:type] == :minus
@@ -97,31 +86,19 @@ module CommandSearch
     end
 
     def clean_ununused!(input)
-      input.map! do |x|
-        next if x[:type] == :paren && x[:value].is_a?(String)
-        next if x[:nest_type] == :colon && x[:value].empty?
-        if x[:nest_type] == :compare && x[:value].length < 2
-          x = clean_ununused!(x[:value]).first
-        end
-        next x unless x && x[:type] == :nest
-        x[:value] = clean_ununused!(x[:value])
-        x
-      end
-      input.compact!
-      input
+      input.reject! { |x| x[:type] == :paren && x[:value].is_a?(String) }
     end
 
-    def parse(input)
-      out = input
-      clean_ununusable!(out)
-      unchain!([:colon, :compare], out)
-      out = group_parens(out)
-      cluster!(:colon, out)
-      cluster!(:compare, out)
-      cluster!(:minus, out, :prefix)
-      cluster!(:pipe, out)
-      clean_ununused!(out)
-      out
+    def parse!(input)
+      clean_ununusable!(input)
+      unchain!([:colon, :compare], input)
+      group_parens!(input)
+      cluster!(:colon, input)
+      cluster!(:compare, input)
+      cluster!(:minus, input, :prefix)
+      cluster!(:pipe, input)
+      clean_ununused!(input)
+      input
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: command_search
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - zumbalogy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-08 00:00:00.000000000 Z
+date: 2018-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chronic