command_search 0.11.2 → 0.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9a7f59d4e3aefbd46963b94d52d18d49d63263ab51ceb31a207ee17ca23bf1b
-  data.tar.gz: 43fe311f65ec44dd89dcb997f0b61daa1347466f63fae1721c0168eb62bfa377
+  metadata.gz: 8c1b899c749aee5b7a81173484fb0fa69eaffd2ab96a26cc3bff7fb7293c5058
+  data.tar.gz: 95c7404d1176cbfb7db75b07323c2e51c13d449c7dc111f53db15db04982d5cf
 SHA512:
-  metadata.gz: f9751ac591a874cf99009d28fc691b6543b5fc038dbbb6d7a7b063cf47f134da0e8ee500300877565e5c2b4164f82a446d983c9a6730c2eab35a86a6ae6a92ed
-  data.tar.gz: 47173f4d0904edcb9ddcbd1f2a24e00f9cd70d528c9234cd1840c861cb4cb7e85681bc6b3362fb73fefff095d16cb6aa277f83027185bc5068ed43c3b5b9b757
+  metadata.gz: bbcf93763eceef8ce66e809603557bf8a21273c41167fdbac2ab080138af2341dd1e98fb79aa66294e8d6bca32af163b88b38f888d80c929f73f0ec9b5aec3dd
+  data.tar.gz: c748c0a6c709c665c1028a46072c6536966d07f6d4e665ca55058e28d11f82253fdc94b3d5d78f594e0b3df2c65d55eff4e33ae865d34abc319e4e788a3d76c0

data/lib/command_search.rb

@@ -40,7 +40,7 @@ module CommandSearch
   end
 
   def search(source, query, options)
-    if source.respond_to?(:mongo_client) && source.queryable
+    if source.respond_to?(:mongo_client)
       ast = CommandSearch.build(:mongo, query, options)
       return source.where(ast)
     end

data/lib/command_search/parser.rb

@@ -2,127 +2,136 @@ module CommandSearch
   module Parser
     module_function
 
-    def group_parens!(input)
+    def group_parens!(ast)
       i = 0
       opening_idxs = []
-      while i < input.length
-        next i += 1 unless input[i][:type] == :paren
-        if input[i][:value] == '('
+      while i < ast.length
+        next i += 1 unless ast[i][:type] == :paren
+        if ast[i][:value] == '('
           opening_idxs.push(i)
-          input.delete_at(i)
+          ast.delete_at(i)
           next
         end
-        input.delete_at(i)
+        ast.delete_at(i)
         opening = opening_idxs.pop()
         next unless opening
-        val = input.slice(opening, i - opening)
+        val = ast.slice(opening, i - opening)
         if val.count > 1
-          input[opening..(i - 1)] = { type: :and, value: val }
+          ast[opening..(i - 1)] = { type: :and, value: val }
           i -= val.length
           next
         elsif val.count == 1
-          input[opening] = val.first
+          ast[opening] = val.first
         end
       end
     end
 
-    def cluster_cmds!(input)
+    def cluster_cmds!(ast)
       i = 1
-      while i < input.length - 1
-        type = input[i][:type]
+      while i < ast.length - 1
+        type = ast[i][:type]
         next i += 1 unless type == :colon || type == :compare
-        input[(i - 1)..(i + 1)] = {
+        ast[(i - 1)..(i + 1)] = {
           type: type,
-          nest_op: input[i][:value],
-          value: [input[i - 1], input[i + 1]]
+          nest_op: ast[i][:value],
+          value: [ast[i - 1], ast[i + 1]]
         }
       end
     end
 
-    def cluster_or!(input)
+    def cluster_or!(ast)
       i = 0
-      while i < input.length
-        type = input[i][:type]
-        cluster_or!(input[i][:value]) if type == :and || type == :not
+      while i < ast.length
+        type = ast[i][:type]
+        cluster_or!(ast[i][:value]) if type == :and || type == :not
         next i += 1 unless type == :pipe
-        if i == 0 || i == input.length - 1
-          input.delete_at(i)
+        if i == 0 || i == ast.length - 1
+          ast.delete_at(i)
           next
         end
-        val = [input[i - 1], input[i + 1]]
+        val = [ast[i - 1], ast[i + 1]]
         cluster_or!(val)
-        input[(i - 1)..(i + 1)] = { type: :or, value: val }
+        ast[i][:type] = :or
+        ast[i][:value] = val
+        ast.delete_at(i + 1)
+        ast.delete_at(i - 1)
       end
     end
 
-    def cluster_not!(input)
-      i = input.length
+    def cluster_not!(ast)
+      i = ast.length
       while i > 0
         i -= 1
-        type = input[i][:type]
-        cluster_not!(input[i][:value]) if type == :and
+        type = ast[i][:type]
+        cluster_not!(ast[i][:value]) if type == :and
         next unless type == :minus
-        if i == input.length - 1
-          input.delete_at(i)
+        if i == ast.length - 1
+          ast.delete_at(i)
           next
         end
-        input[i..(i + 1)] = {
-          type: :not,
-          value: [input[i + 1]]
-        }
+        ast[i][:type] = :not
+        ast[i][:value] = [ast[i + 1]]
+        ast.delete_at(i + 1)
       end
     end
 
-    def unchain!(input, types)
-      i = 0
-      while i < input.length - 2
-        left = input[i][:type]
-        right = input[i + 2][:type]
-        if types.include?(left) && types.include?(right)
-          input.insert(i + 1, input[i + 1].clone())
-        end
+    def unchain!(ast)
+      i = 1
+      while i < ast.length - 3
+        left = ast[i][:type]
+        right = ast[i + 2][:type]
         i += 1
+        next unless left == :colon || left == :compare
+        next unless right == :colon || right == :compare
+        ast.insert(i, ast[i].clone())
       end
     end
 
-    def merge_strs(input, (x, y))
-      if input[y] && input[y][:type] == :str
-        values = input.map { |x| x[:value] }
-        { type: :str, value: values.join() }
-      else
-        input[x][:type] = :str
-        input
-      end
+    def r_merge!(ast, i)
+      ast[i][:type] = :str
+      return unless ast[i + 1] && ast[i + 1][:type] == :str
+      ast[i][:value] = ast[i][:value] + ast[i + 1][:value]
+      ast.delete_at(i + 1)
     end
 
-    def clean_ununusable!(input)
-      i = 1
-      while i < input.length
-        next i += 1 unless input[i][:type] == :minus
-        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, :quote].include?(input[i - 1][:type]) &&
-          [:str, :number, :quote].include?(input[i + 1][:type])
+    def l_merge!(ast, i)
+      ast[i][:type] = :str
+      return unless ast[i - 1] && ast[i - 1][:type] == :str
+      ast[i][:value] = ast[i - 1][:value] + ast[i][:value]
+      ast.delete_at(i - 1)
+    end
 
-        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
+    def clean!(ast)
+      return unless ast.any?
+      if ast[0][:type] == :colon || ast[0][:type] == :compare
+        r_merge!(ast, 0)
+      end
+      if ast[-1][:type] == :colon || ast[-1][:type] == :compare
+        l_merge!(ast, ast.length - 1)
+      end
+      i = 1
+      while i < ast.length - 1
+        next i += 1 unless ast[i][:type] == :colon || ast[i][:type] == :compare
+        if ast[i + 1][:type] == :minus
+          r_merge!(ast, i + 1)
+        elsif ![:str, :number, :quote].include?(ast[i - 1][:type])
+          r_merge!(ast, i)
+        elsif ![:str, :number, :quote].include?(ast[i + 1][:type])
+          l_merge!(ast, i)
+        else
+          i += 1
+        end
       end
     end
 
-    def parse!(input)
-      clean_ununusable!(input)
-      unchain!(input, [:colon, :compare])
-      cluster_cmds!(input)
-      group_parens!(input)
-      cluster_not!(input)
-      cluster_or!(input)
-      input
+    def parse!(ast)
+      clean!(ast)
+      unchain!(ast)
+      cluster_cmds!(ast)
+      group_parens!(ast)
+      cluster_not!(ast)
+      cluster_or!(ast)
+      ast
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: command_search
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.11.3
 platform: ruby
 authors:
 - zumbalogy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-19 00:00:00.000000000 Z
+date: 2020-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chronic
@@ -60,7 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Let users query collections with ease.