command_search 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0ff69a298e109d79d1cf70f7bc0d1470129d447d
-  data.tar.gz: 37bfc67ff6702e307087611b5e75db52ce6334c7
+SHA256:
+  metadata.gz: e2547eed6e11ca87fb0673811fe0e71c8b46438cb4608973965bb8861519a5fe
+  data.tar.gz: 0b89c973dbb4a2ee846bed3b3a8fd68de382db2a1ba3bab8a75ca29bb8803e87
 SHA512:
-  metadata.gz: b53dbc26c9a8db5cd13c48b4def9065f29031fab0ed1336cefbb94f6e197ce7172db18e5b81937a4ee68d08a0ec700cd90145bf0996f1d5af32d70423b6f10ec
-  data.tar.gz: 5f5a24aed587abe88c7408c3855360826b7fedcc00ab7f242e161717a8858465f82196aacb5d046ed9b98b985e6e88f843aeeb97b2b47dfcb4da00038cd6b318
+  metadata.gz: cf30f8ae6d579a5c9be52aca78fb622b6a12f3ced8c431226e467b7917fe75c5f87f14527a3f69567529ec8413a4f2634bd252652198ba6caaa8b2b0e2d6b972
+  data.tar.gz: 631d41b06396eb6db76ce6338707ee53bef5ecc1a26f5667854ff583b42091fcde5e1ff2670ccd73659c0e683d572195706f8bf46d3d03ca390b8accc2b6572e

data/lib/command_search/command_dealiaser.rb

@@ -7,10 +7,10 @@ module CommandSearch
       key.to_s
     end
 
-    def dealias_values((key_node, seach_node), aliases)
+    def dealias_values((key_node, search_node), aliases)
       new_key = dealias_key(key_node[:value], aliases)
       key_node[:value] = new_key
-      [key_node, seach_node]
+      [key_node, search_node]
     end
 
     def unnest_unaliased(node, aliases)

data/lib/command_search/lexer.rb

@@ -2,103 +2,43 @@ module CommandSearch
   module Lexer
     module_function
 
-    # This class takes a string and returns it tokenized into
-    # atoms/words, along with their type. It is coupled to the
-    # parser in names of char_types and output data structure.
-
-    # This currently does not support numbers with commas in them
-
-    def char_type(char)
-      case char
-      when /["']/
-        :quote
-      when /[()]/
-        :paren
-      when /[<>]/
-        :compare
-      when /\s/
-        :space
-      when /\d/
-        :number
-      when '.'
-        :period
-      when '-'
-        :minus
-      when ':'
-        :colon
-      when '='
-        :equal
-      when '|'
-        :pipe
-      else
-        :str
-      end
-    end
-
-    def char_token(char)
-      { type: char_type(char), value: char }
-    end
-
-    def value_indices(match, list)
-      list.each_index.select { |i| list[i][:value] == match }
-    end
-
-    def group_quoted_strings(input)
-      out = input
-      while value_indices("'", out).length >= 2 || value_indices('"', out).length >= 2
-        (a, b) = value_indices("'", out).first(2)
-        (c, d) = value_indices('"', out).first(2)
-        if a && b && (c.nil? || (a < c))
-          (x, y) = [a, b]
-        else
-          (x, y) = [c, d]
+    def lex(input)
+      out = []
+      i = 0
+      while i < input.length
+        match = nil
+        case input[i..-1]
+        when /^\s+/
+          i += Regexp.last_match[0].length
+          next
+        when /^"(.*?)"/
+          match = Regexp.last_match[1]
+          type = :quoted_str
+        when /^'(.*?)'/
+          match = Regexp.last_match[1]
+          type = :quoted_str
+        when /^\-?\d+(\.\d+)?(?=$|[\s"':|<>)(])/
+          type = :number
+        when /^\|+/
+          type = :pipe
+        when /^-/
+          type = :minus
+        when /^:/
+          type = :colon
+        when /^[()]/
+          type = :paren
+        when /^[<>]=?/
+          type = :compare
+        when /^\d*[^\d\s:)][^\s"'|:<>)(]*/
+          type = :str
+        when /^./
+          type = :str
         end
-        vals = out[x..y].map { |i| i[:value] }
-        trimmed_vals = vals.take(vals.length - 1).drop(1)
-        out[x..y] = { type: :quoted_str, value: trimmed_vals.join }
+        match = match || Regexp.last_match[0]
+        out.push(type: type, value: match)
+        i += Regexp.last_match[0].length
       end
       out
     end
-
-    def group_pattern(input, group_type, pattern)
-      out = input
-      len = pattern.count
-      while (out.map { |x| x[:type] }).each_cons(len).find_index(pattern)
-        i = (out.map { |x| x[:type] }).each_cons(len).find_index(pattern)
-        span = i..(i + len - 1)
-        val = out[span].map { |x| x[:value] }.join()
-        out[span] = { type: group_type, value: val }
-      end
-      out
-    end
-
-    def full_tokens(char_token_list)
-      out = char_token_list.clone
-
-      out = group_quoted_strings(out)
-
-      out = group_pattern(out, :pipe,    [:pipe,    :pipe])
-      out = group_pattern(out, :compare, [:compare, :equal])
-
-      out = group_pattern(out, :number,  [:number,  :period, :number])
-      out = group_pattern(out, :number,  [:number,  :number])
-      out = group_pattern(out, :number,  [:minus,   :number])
-
-      out = group_pattern(out, :str,     [:equal])
-      out = group_pattern(out, :str,     [:period])
-      out = group_pattern(out, :str,     [:number,  :str])
-      out = group_pattern(out, :str,     [:number,  :minus])
-      out = group_pattern(out, :str,     [:str,     :number])
-      out = group_pattern(out, :str,     [:str,     :minus])
-      out = group_pattern(out, :str,     [:str,     :str])
-
-      out = out.reject { |x| x[:type] == :space }
-      out
-    end
-
-    def lex(input)
-      char_tokens = input.split('').map(&method(:char_token))
-      full_tokens(char_tokens)
-    end
   end
 end

data/lib/command_search/memory.rb

@@ -29,7 +29,7 @@ module CommandSearch
         item[cmd][/#{Regexp.escape(cmd_search)}/i]
       elsif val[1][:type] == :quoted_str
         regex = /\b#{Regexp.escape(cmd_search)}\b/
-        if cmd_search.first[/\W/] || cmd_search.last[/\W/]
+        if cmd_search[/(^\W)|(\W$)/]
           head_border = '(?<=^|[^:+\w])'
           tail_border = '(?=$|[^:+\w])'
           regex = Regexp.new(head_border + Regexp.escape(cmd_search) + tail_border)
@@ -84,7 +84,7 @@ module CommandSearch
         when nil
           if node[:type] == :quoted_str
             regex = /\b#{Regexp.escape(val)}\b/
-            if val.first[/\W/] || val.last[/\W/]
+            if val[/(^\W)|(\W$)/]
               head_border = '(?<=^|[^:+\w])'
               tail_border = '(?=$|[^:+\w])'
               regex = Regexp.new(head_border + Regexp.escape(val) + tail_border)

data/lib/command_search/mongoer.rb

@@ -9,13 +9,15 @@ module CommandSearch
       fields = [fields] unless fields.is_a?(Array)
       if ast_node[:type] == :quoted_str
         regex = /\b#{Regexp.escape(str)}\b/
-        if str.first[/\W/] || str.last[/\W/]
+        if str[/(^\W)|(\W$)/]
           head_border = '(?<=^|[^:+\w])'
           tail_border = '(?=$|[^:+\w])'
           regex = Regexp.new(head_border + Regexp.escape(str) + tail_border)
         end
       else
-        regex = /#{Regexp.escape(str)}/i
+        # 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
       end
       if ast_node[:negate]
         forms = fields.map { |f| { f => { '$not' => regex } } }
@@ -87,7 +89,7 @@ module CommandSearch
       elsif type == String
         if search_type == :quoted_str
           val = /\b#{Regexp.escape(raw_val)}\b/
-          if raw_val.first[/\W/] || raw_val.last[/\W/]
+          if raw_val[/(^\W)|(\W$)/]
             head_border = '(?<=^|[^:+\w])'
             tail_border = '(?=$|[^:+\w])'
             val = Regexp.new(head_border + Regexp.escape(raw_val) + tail_border)

data/lib/command_search/parser.rb

@@ -60,6 +60,7 @@ module CommandSearch
     def clean_ununused_syntax(input)
       out = 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_syntax(x[:value]).first
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: command_search
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - zumbalogy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-03 00:00:00.000000000 Z
+date: 2018-11-02 00:00:00.000000000 Z
 dependencies: []
 description: Query collections with ease and without an engine like Elasticsearch.
 email: 
@@ -44,7 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: A friendly search gem for users and developers.