command_search 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa471a870d21295459efa58aa18e3777752841dc0cfec3033a6423996ed2d98c
-  data.tar.gz: 37a0b72e6cb764c90fd14eb44b0a1c096d4e6c6e2756a4715db3e02471aa6889
+  metadata.gz: e1d615f992c4521f18821e9b3ee2d96fb800095abeadf549f59b8c24fb6419b6
+  data.tar.gz: df4378e2ab56dc1ee3299582f8a9aed11d4d64d5dd1d3d6d38a0d208a0d48f1f
 SHA512:
-  metadata.gz: fe02049b5e6eec1b62ffa6d030a747312b661f4db05befb66f5e3585bf0b5b679f65c10c7ba3348a19de97ecdb0d4f9f19b2e5466b75bd4604658b66021c6fe0
-  data.tar.gz: a5e0fa90644d5c7dd3346e1b9c7e43ef04c6e652f9f293ac59b468a2667bb388be8614854680612b62cda2812179fd800ee45a9e4229c7d4774760facd2b0b79
+  metadata.gz: 5707ed405d3f6133a6437821b5df18a076b67c299334a226639d8d9e62486f3f385a50907a2bcc57c63a86280125745f3a00975b880086539df899b1106a5acb
+  data.tar.gz: 312e172cc413d7f0d2efb127fd7858454b383b6eed72d1102a416f8d408eefaa831247caf5b27c67ae4959b7ac50871ccf5b05d6eb4abaa6cc6dea40d61425c7

data/lib/command_search.rb

@@ -6,28 +6,62 @@ load(__dir__ + '/command_search/optimizer.rb')
 
 load(__dir__ + '/command_search/backends/memory.rb')
 load(__dir__ + '/command_search/backends/mongoer.rb')
+load(__dir__ + '/command_search/backends/postgres.rb')
+load(__dir__ + '/command_search/backends/sqlite.rb')
+load(__dir__ + '/command_search/backends/mysql.rb')
+load(__dir__ + '/command_search/backends/mysql_v5.rb')
 
 class Boolean; end
 
 module CommandSearch
   module_function
 
-  def search(source, query, options)
+  def build(type, query, options)
     aliases = options[:aliases] || {}
     fields = options[:fields] || {}
-
     aliased_query = Aliaser.alias(query, aliases)
     ast = Lexer.lex(aliased_query)
-
     Parser.parse!(ast)
     Optimizer.optimize!(ast)
+    if type == :postgres
+      Normalizer.normalize!(ast, fields, false)
+      return Postgres.build_query(ast)
+    end
+    if type == :sqlite
+      Normalizer.normalize!(ast, fields, false)
+      return Sqlite.build_query(ast)
+    end
+    if type == :mysql
+      Normalizer.normalize!(ast, fields, false)
+      return Mysql.build_query(ast)
+    end
+    if type == :mysqlV5
+      Normalizer.normalize!(ast, fields, false)
+      return MysqlV5.build_query(ast)
+    end
     Normalizer.normalize!(ast, fields)
+    return Mongoer.build_query(ast) if type == :mongo
+    ast
+  end
 
-    if source.respond_to?(:mongo_client) && source.queryable
-      mongo_query = Mongoer.build_query(ast)
-      return source.where(mongo_query)
+  def search(source, query, options)
+    if source.respond_to?(:mongo_client)
+      ast = CommandSearch.build(:mongo, query, options)
+      return source.where(ast)
     end
-
-    source.select { |x| Memory.check(x, ast) }
+    if source.respond_to?(:postgresql_connection)
+      ast = CommandSearch.build(:postgres, query, options)
+      return source.where(ast)
+    end
+    if source.respond_to?(:sqlite3_connection)
+      ast = CommandSearch.build(:sqlite, query, options)
+      return source.where(ast)
+    end
+    if source.respond_to?(:mysql2_connection)
+      ast = CommandSearch.build(:mysql, query, options)
+      return source.where(ast)
+    end
+    ast = CommandSearch.build(:other, query, options)
+    source.select { |x| CommandSearch::Memory.check(x, ast) }
   end
 end

data/lib/command_search/backends/mysql.rb

@@ -0,0 +1,110 @@
+# NOTE: This module supports does not support MariaDB or eariler Mysql versions than 8.0, due to
+# changes in how word breaks are handled in regexes.
+
+module CommandSearch
+  module Mysql
+    module_function
+
+    def quote_string(str)
+      # activerecord/lib/active_record/connection_adapters/abstract/quoting.rb:62
+      str.gsub('\\', '\&\&').gsub("'", "''")
+    end
+
+    def build_quoted_regex(str)
+      str = Regexp.escape(str)
+      str = quote_string(str)
+      if str[/(^\W)|(\W$)/]
+        head_border = '(^|[^:+[[:alnum:]]])'
+        tail_border = '($|[^:+[[:alnum:]]])'
+        return head_border + str + tail_border
+      end
+      '\\\\b' + str + '\\\\b'
+    end
+
+    def command_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      return '0 = 1' if field == '__CommandSearch_dummy_key__'
+      if type == Boolean || type == :existence
+        if val
+          return "(NOT ((#{field} IS NULL) OR (#{field} LIKE '0')))"
+        end
+        return "((#{field} IS NULL) OR (#{field} LIKE '0'))"
+      end
+      if type == Time
+        return '0 = 1' unless val
+        return "
+          (
+            (#{field} > '#{val[0] - 1}') AND
+            (#{field} <= '#{val[1] - 1}') AND
+            (#{field} IS NOT NULL)
+          )
+        "
+      end
+      if type == :quote
+        val = build_quoted_regex(val)
+        return "(REGEXP_LIKE(#{field}, '#{val}', 'c') AND (#{field} IS NOT NULL))"
+      end
+      if type == :number
+        op = '='
+      else # type == :str
+        op = 'LIKE'
+        val = quote_string(val)
+        val.gsub!('%', '\%')
+        val.gsub!('_', '\_')
+        val = "'%#{val}%'"
+      end
+      "((#{field} #{op} #{val}) AND (#{field} IS NOT NULL))"
+    end
+
+    def compare_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      op = node[:nest_op]
+      if node[:compare_across_fields]
+        "
+          (
+            (#{field} #{op} #{val}) AND
+            (#{field} IS NOT NULL) AND
+            (#{val} IS NOT NULL)
+          )
+        "
+      elsif type == Time && val
+        "(#{field} #{op} '#{val}') AND (#{field} IS NOT NULL)"
+      elsif val.is_a?(Numeric) || val == val.to_i.to_s || val == val.to_f.to_s
+        "(#{field} #{op} #{val}) AND (#{field} IS NOT NULL)"
+      else
+        '0 = 1'
+      end
+    end
+
+    def build_query(ast)
+      out = []
+      ast = [ast] unless ast.is_a?(Array)
+      ast.each do |node|
+        type = node[:type]
+        if type == :colon
+          out.push(command_search(node))
+        elsif type == :compare
+          out.push(compare_search(node))
+        elsif type == :and
+          out.push(build_query(node[:value]))
+        elsif type == :or
+          clauses = node[:value].map { |x| build_query(x) }
+          clause = clauses.join(' OR ')
+          out.push("(#{clause})")
+        elsif type == :not
+          clause = build_query(node[:value])
+          out.push("NOT (#{clause})")
+        end
+      end
+      out.join(' AND ')
+    end
+  end
+end

data/lib/command_search/backends/mysql_v5.rb

@@ -0,0 +1,108 @@
+# NOTE: This module supports MariaDB and MySql 5 with its distinct word break regex rules.
+
+module CommandSearch
+  module MysqlV5
+    module_function
+
+    def quote_string(str)
+      # activerecord/lib/active_record/connection_adapters/abstract/quoting.rb:62
+      str.gsub('\\', '\&\&').gsub("'", "''")
+    end
+
+    def build_quoted_regex(str)
+      str = Regexp.escape(str)
+      str = quote_string(str)
+      if str[/(^\W)|(\W$)/]
+        head_border = '(^|[[:<:]]|\\\\()'
+        tail_border = '($|[[:>:]]|\\\\))'
+        return head_border + str + tail_border
+      end
+      '[[:<:]]' + str + '[[:>:]]'
+    end
+
+    def command_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      return '0 = 1' if field == '__CommandSearch_dummy_key__'
+      if type == Boolean || type == :existence
+        if val
+          return "(NOT ((#{field} IS NULL) OR (#{field} LIKE '0')))"
+        end
+        return "((#{field} IS NULL) OR (#{field} LIKE '0'))"
+      end
+      if type == Time
+        return '0 = 1' unless val
+        return "
+          (
+            (#{field} > '#{val[0] - 1}') AND
+            (#{field} <= '#{val[1] - 1}') AND
+            (#{field} IS NOT NULL)
+          )
+        "
+      end
+      if type == :quote
+        op = 'RLIKE BINARY'
+        val = "'#{build_quoted_regex(val)}'"
+      elsif type == :number
+        op = '='
+      else # type == :str
+        op = 'LIKE'
+        val = quote_string(val)
+        val.gsub!('%', '\%')
+        val.gsub!('_', '\_')
+        val = "'%#{val}%'"
+      end
+      "((#{field} #{op} #{val}) AND (#{field} IS NOT NULL))"
+    end
+
+    def compare_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      op = node[:nest_op]
+      if node[:compare_across_fields]
+        "
+          (
+            (#{field} #{op} #{val}) AND
+            (#{field} IS NOT NULL) AND
+            (#{val} IS NOT NULL)
+          )
+        "
+      elsif type == Time && val
+        "(#{field} #{op} '#{val}') AND (#{field} IS NOT NULL)"
+      elsif val.is_a?(Numeric) || val == val.to_i.to_s || val == val.to_f.to_s
+        "(#{field} #{op} #{val}) AND (#{field} IS NOT NULL)"
+      else
+        '0 = 1'
+      end
+    end
+
+    def build_query(ast)
+      out = []
+      ast = [ast] unless ast.is_a?(Array)
+      ast.each do |node|
+        type = node[:type]
+        if type == :colon
+          out.push(command_search(node))
+        elsif type == :compare
+          out.push(compare_search(node))
+        elsif type == :and
+          out.push(build_query(node[:value]))
+        elsif type == :or
+          clauses = node[:value].map { |x| build_query(x) }
+          clause = clauses.join(' OR ')
+          out.push("(#{clause})")
+        elsif type == :not
+          clause = build_query(node[:value])
+          out.push("NOT (#{clause})")
+        end
+      end
+      out.join(' AND ')
+    end
+  end
+end

data/lib/command_search/backends/postgres.rb

@@ -0,0 +1,108 @@
+module CommandSearch
+  module Postgres
+    module_function
+
+    def quote_string(str)
+      # activerecord/lib/active_record/connection_adapters/abstract/quoting.rb:62
+      str.gsub('\\', '\&\&').gsub("'", "''")
+    end
+
+    def build_quoted_regex(input)
+      str = quote_string(input)
+      str = Regexp.escape(str)
+      if str[/(^\W)|(\W$)/]
+        head_border = '(^|[^:+\w])'
+        tail_border = '($|[^:+\w])'
+        return head_border + str + tail_border
+      end
+      '\m' + str + '\y'
+    end
+
+    def command_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      return '0 = 1' if field == '__CommandSearch_dummy_key__'
+      if type == Boolean || type == :existence
+        false_val = "'f'"
+        false_val = 0 if field_node[:field_type] == Numeric
+        if val
+          return "NOT ((#{field} = #{false_val}) OR (#{field} IS NULL))"
+        end
+        return "((#{field} = #{false_val}) OR (#{field} IS NULL))"
+      end
+      if type == Time
+        return '0 = 1' unless val
+        return "
+          (
+            (#{field} >= '#{val[0]}') AND
+            (#{field} < '#{val[1]}') AND
+            (#{field} IS NOT NULL)
+          )
+        "
+      end
+      if type == :quote
+        op = '~'
+        val = "'#{build_quoted_regex(val)}'"
+      elsif type == :str
+        op = '~~*'
+        val = quote_string(val)
+        val.gsub!('%', '\%')
+        val.gsub!('_', '\_')
+        val = "'%#{val}%'"
+      elsif type == :number
+        op = '='
+      end
+      "(#{field} #{op} #{val}) AND (#{field} IS NOT NULL)"
+    end
+
+    def compare_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      op = node[:nest_op]
+      if node[:compare_across_fields]
+        "
+          (
+            (#{field} #{op} #{val}) AND
+            (#{field} IS NOT NULL) AND
+            (#{val} IS NOT NULL)
+          )
+        "
+      elsif type == Time && val
+        "(#{field} #{op} '#{val}') AND (#{field} IS NOT NULL)"
+      elsif val.is_a?(Numeric) || val == val.to_i.to_s || val == val.to_f.to_s
+        "(#{field} #{op} #{val}) AND (#{field} IS NOT NULL)"
+      else
+        '0 = 1'
+      end
+    end
+
+    def build_query(ast)
+      out = []
+      ast = [ast] unless ast.is_a?(Array)
+      ast.each do |node|
+        type = node[:type]
+        if type == :colon
+          out.push(command_search(node))
+        elsif type == :compare
+          out.push(compare_search(node))
+        elsif type == :and
+          out.push(build_query(node[:value]))
+        elsif type == :or
+          clauses = node[:value].map { |x| build_query(x) }
+          clause = clauses.join(' OR ')
+          out.push("(#{clause})")
+        elsif type == :not
+          clause = build_query(node[:value])
+          out.push("NOT (#{clause})")
+        end
+      end
+      out.join(' AND ')
+    end
+  end
+end

data/lib/command_search/backends/sqlite.rb

@@ -0,0 +1,109 @@
+module CommandSearch
+  module Sqlite
+    module_function
+
+    def quote_string(str)
+      # activerecord/lib/active_record/connection_adapters/abstract/quoting.rb:62
+      str.gsub('\\', '\&\&').gsub("'", "''")
+    end
+
+    def command_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      return '0 = 1' if field == '__CommandSearch_dummy_key__'
+      if type == Boolean || type == :existence
+        if val
+          return "NOT ((#{field} = 0) OR (#{field} IS NULL))"
+        end
+        return "((#{field} = 0) OR (#{field} IS NULL))"
+      end
+      if type == Time
+        return '0 = 1' unless val
+        return "
+          (
+            (#{field} > '#{val[0] - 1}') AND
+            (#{field} <= '#{val[1] - 1}') AND
+            (#{field} IS NOT NULL)
+          )
+        "
+      end
+      if type == :quote
+        val = quote_string(val)
+        val.gsub!('[', '[[]')
+        val.gsub!('*', '[*]')
+        val.gsub!('?', '[?]')
+        border = '[ .,()?"\'\']'
+        return "
+          (
+            (#{field} IS NOT NULL) AND
+            (
+              (#{field} GLOB '#{val}') OR
+              (#{field} GLOB '*#{border}#{val}#{border}*') OR
+              (#{field} GLOB '*#{border}#{val}') OR
+              (#{field} GLOB '#{val}#{border}*')
+            )
+          )
+        "
+      elsif type == :str
+        op = 'LIKE'
+        val = quote_string(val)
+        val.gsub!('%', '\%')
+        val.gsub!('_', '\_')
+        val = "'%#{val}%' ESCAPE '\\'"
+      elsif type == :number
+        op = '='
+      end
+      "((#{field} #{op} #{val}) AND (#{field} IS NOT NULL))"
+    end
+
+    def compare_search(node)
+      field_node = node[:value].first
+      field = field_node[:value]
+      search_node = node[:value].last
+      val = search_node[:value]
+      type = search_node[:type]
+      op = node[:nest_op]
+      if node[:compare_across_fields]
+        "
+          (
+            (#{field} #{op} #{val}) AND
+            (#{field} IS NOT NULL) AND
+            (#{val} IS NOT NULL)
+          )
+        "
+      elsif type == Time && val
+        "(#{field} #{op} '#{val}') AND (#{field} IS NOT NULL)"
+      elsif val.is_a?(Numeric) || val == val.to_i.to_s || val == val.to_f.to_s
+        "(#{field} #{op} #{val}) AND (#{field} IS NOT NULL)"
+      else
+        '0 = 1'
+      end
+    end
+
+    def build_query(ast)
+      out = []
+      ast = [ast] unless ast.is_a?(Array)
+      ast.each do |node|
+        type = node[:type]
+        if type == :colon
+          out.push(command_search(node))
+        elsif type == :compare
+          out.push(compare_search(node))
+        elsif type == :and
+          out.push(build_query(node[:value]))
+        elsif type == :or
+          clauses = node[:value].map { |x| build_query(x) }
+          clause = clauses.join(' OR ')
+          out.push("(#{clause})")
+        elsif type == :not
+          clause = build_query(node[:value])
+          out.push("NOT (#{clause})")
+        end
+      end
+      out.join(' AND ')
+    end
+  end
+end

data/lib/command_search/normalizer.rb

@@ -53,8 +53,8 @@ module CommandSearch
       str = Regexp.escape(raw)
       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])'
+      border_a = '(^|[^:+\w])'
+      border_b = '($|[^:+\w])'
       node[:value] = Regexp.new(border_a + str + border_b)
     end
 
@@ -96,22 +96,28 @@ module CommandSearch
       { type: :or, value: new_val }
     end
 
-    def type_cast!(node, fields)
+    def type_cast!(node, fields, cast_all)
       (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]
+      type = Numeric if type == Integer
+      key_node[:field_type] = 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)
+      return cast_numeric!(search_node) if Numeric == type
+      if cast_all
+        cast_regex!(search_node)
+      else
+        search_node[:type] = :str if search_node[:type] == :number
+      end
     end
 
-    def normalize!(ast, fields)
+    def normalize!(ast, fields, cast_all = true)
       ast.map! do |node|
         if node[:type] == :and || node[:type] == :or || node[:type] == :not
-          normalize!(node[:value], fields)
+          normalize!(node[:value], fields, cast_all)
           next node
         end
         if node[:type] == :colon || node[:type] == :compare
@@ -127,9 +133,9 @@ module CommandSearch
           node = split_general_fields(node, fields)
         end
         if node[:type] == :or
-          node[:value].each { |x| type_cast!(x, fields) }
+          node[:value].each { |x| type_cast!(x, fields, cast_all) }
         else
-          type_cast!(node, fields)
+          type_cast!(node, fields, cast_all)
         end
         node
       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.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - zumbalogy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-14 00:00:00.000000000 Z
+date: 2020-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chronic
@@ -34,6 +34,10 @@ files:
 - lib/command_search/aliaser.rb
 - lib/command_search/backends/memory.rb
 - lib/command_search/backends/mongoer.rb
+- lib/command_search/backends/mysql.rb
+- lib/command_search/backends/mysql_v5.rb
+- lib/command_search/backends/postgres.rb
+- lib/command_search/backends/sqlite.rb
 - lib/command_search/lexer.rb
 - lib/command_search/normalizer.rb
 - lib/command_search/optimizer.rb
@@ -57,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Let users query collections with ease.