command_search 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 217fdaec3f53844fbda942d9b8f9cb6422cfd422
+  data.tar.gz: ffbc227be18fa8fcd947dd42889838719921cbed
+SHA512:
+  metadata.gz: ec86ff8eccc714a7ac0aae2a36f78c6a36bad5fcfb87fd61dbfbb8544b27f008f787604a3e50241c309ce8335177097e78c311487873baee09043a5d3243fa4e
+  data.tar.gz: be520d824f7f9ef919089da78adfdde811a2e1e072b791cf5ec1fa4f462d09b538d7272e7417083992305ee4e4dbffa15a42efb3c11deadd5b7b4cfb1a796f93

data/lib/command_search/aliaser.rb

@@ -0,0 +1,46 @@
+module CommandSearch
+  module Aliaser
+    module_function
+
+    def build_regex(str)
+      head_border = '(?<=^|\s|[|(-])'
+      tail_border = '(?=$|\s|[|)])'
+      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'/]
+    end
+
+    def alias_item(query, alias_key, alias_value)
+      if alias_key.is_a?(Regexp)
+        pattern = alias_key
+      else
+        pattern = build_regex(alias_key.to_s)
+      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)
+        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
+        end
+      end
+      head + replacement + tail
+    end
+
+    def alias(query, aliases)
+      aliases.reduce(query) { |q, (k, v)| alias_item(q, k, v) }
+    end
+  end
+end

data/lib/command_search/command_dealiaser.rb

@@ -0,0 +1,44 @@
+module CommandSearch
+  module CommandDealiaser
+    module_function
+
+    def dealias_key(key, aliases)
+      key = aliases[key.to_sym] while aliases[key.to_sym].is_a?(Symbol)
+      key.to_s
+    end
+
+    def dealias_values((key_node, seach_node), aliases)
+      new_key = dealias_key(key_node[:value], aliases)
+      key_node[:value] = new_key
+      [key_node, seach_node]
+    end
+
+    def unnest_unaliased(node, aliases)
+      type = node[:nest_type]
+      values = node[:value].map { |x| x[:value].to_sym }
+      return node if type == :colon && aliases[values.first]
+      return node if type == :compare && (values & aliases.keys).any?
+      str_values = values.join(node[:nest_op])
+      { type: :str, value: str_values }
+    end
+
+    def dealias(ast, aliases)
+      ast.flat_map do |x|
+        next x unless x[:nest_type]
+        x[:value] = dealias(x[:value], aliases)
+        next x unless [:colon, :compare].include?(x[:nest_type])
+        x[:value] = dealias_values(x[:value], aliases)
+        x
+      end
+    end
+
+    def decompose_unaliasable(ast, aliases)
+      ast.flat_map do |x|
+        next x unless x[:nest_type]
+        x[:value] = decompose_unaliasable(x[:value], aliases)
+        next x unless [:colon, :compare].include?(x[:nest_type])
+        unnest_unaliased(x, aliases)
+      end
+    end
+  end
+end

data/lib/command_search/lexer.rb

@@ -0,0 +1,104 @@
+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]
+        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 }
+      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

@@ -0,0 +1,102 @@
+require('chronic')
+
+module CommandSearch
+  module Memory
+    module_function
+
+    def command_check(item, val, command_types)
+      cmd = val[0][:value].to_sym
+      cmd_search = val[1][:value]
+      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]
+        else
+          item[cmd] == false
+        end
+      elsif allow_existence_boolean && (cmd_search[/true/i] || cmd_search[/false/i])
+        if cmd_search[/true/i]
+          item[cmd]
+        else
+          item[cmd] == nil
+        end
+      elsif !item.key?(cmd)
+        return false
+      elsif val[1][:type] == :str
+        item[cmd][/#{Regexp.escape(cmd_search)}/mi]
+      elsif val[1][:type] == :quoted_str
+        item[cmd][/\b#{Regexp.escape(cmd_search)}\b/]
+      else
+        item[cmd].to_s[/#{Regexp.escape(cmd_search)}/mi]
+      end
+    end
+
+    def compare_check(item, node, command_types)
+      children = node[:value]
+      cmd = children.find { |c| command_types[c[:value].to_sym] }
+      raw_cmd_type = [command_types[cmd[:value].to_sym]].flatten
+      cmd_type = (raw_cmd_type - [:allow_existence_boolean]).first
+
+      args = children.map do |child|
+        child_val = child[:value]
+        item_val = item[child_val.to_s] || item[child_val.to_sym]
+        item_val ||= child_val unless child == cmd
+        return unless item_val
+        if cmd_type == Time
+          date_start_map = {
+            '<' => :start,
+            '>' => :end,
+            '<=' => :end,
+            '>=' => :start
+          }
+          date_pick = date_start_map[node[:nest_op]]
+          time_str = item_val.gsub(/[\._-]/, ' ')
+          date = Chronic.parse(time_str, { guess: nil })
+          if date_pick == :start
+            date.first
+          else
+            date.last
+          end
+        else
+          item_val
+        end
+      end
+      return unless args.all?
+      fn = node[:nest_op].to_sym.to_proc
+      fn.call(*args.map(&:to_f))
+    end
+
+    def check(item, ast, fields, command_types)
+      field_vals = fields.map { |x| item[x] || item[x.to_s] || item[x.to_sym] }.compact
+      ast_array = ast.is_a?(Array) ? ast : [ast]
+      ast_array.all? do |node|
+        val = node[:value]
+        case node[:nest_type]
+        when nil
+          if node[:type] == :quoted_str
+            field_vals.any? { |x| x.to_s[/\b#{Regexp.escape(val)}\b/] }
+          else
+            field_vals.any? { |x| x.to_s[/#{Regexp.escape(val)}/mi] }
+          end
+        when :colon
+          command_check(item, val, command_types)
+        when :compare
+          compare_check(item, node, command_types)
+        when :pipe
+          val.any? { |v| check(item, v, fields, command_types) }
+        when :minus
+          val.none? { |v| check(item, v, fields, command_types) }
+        when :paren
+          val.all? { |v| check(item, v, fields, command_types) }
+        end
+      end
+    end
+
+    def build_query(ast, fields, command_types = {})
+      proc { |x| check(x, ast, fields, command_types) }
+    end
+  end
+end

data/lib/command_search/mongoer.rb

@@ -0,0 +1,264 @@
+require('chronic')
+
+module CommandSearch
+  module Mongoer
+    module_function
+
+    def build_search(ast_node, fields)
+      str = ast_node[:value]
+      fields = [fields] unless fields.is_a?(Array)
+      if ast_node[:type] == :quoted_str
+        regex = /\b#{Regexp.escape(str)}\b/
+      else
+        regex = /#{Regexp.escape(str)}/mi
+      end
+      if ast_node[:negate]
+        forms = fields.map { |f| { f => { '$not' => regex } } }
+      else
+        forms = fields.map { |f| { f => regex } }
+      end
+      return forms if forms.count < 2
+      if ast_node[:negate]
+        { '$and' => forms }
+      else
+        { '$or' => forms }
+      end
+    end
+
+    def is_bool_str?(str)
+      return true if str[/^true$|^false$/i]
+      false
+    end
+
+    def make_boolean(str)
+      return true if str[/^true$/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]
+      type = raw_type
+
+      raw_val = search_node[:value]
+      search_type = search_node[:type]
+
+      if raw_type.is_a?(Array)
+        is_bool = raw_type.include?(:allow_existence_boolean) && is_bool_str?(raw_val) && search_type != :quoted_str
+        type = (raw_type - [:allow_existence_boolean]).first
+      else
+        is_bool = false
+        type = raw_type
+      end
+
+      if defined?(Boolean) && type == Boolean
+        # val = make_boolean(raw_val)
+        bool = make_boolean(raw_val)
+        bool = !bool if field_node[:negate]
+        val = [
+          { key => { '$exists' => true } },
+          { key => { '$ne' => !bool } }
+        ]
+        key = '$and'
+      elsif is_bool
+        # This returns true for empty arrays, when it probably should not.
+        # Alternativly, something like tags>5 could return things that have more
+        # than 5 tags in the array.
+        # https://stackoverflow.com/questions/22367335/mongodb-check-if-value-exists-for-a-field-in-a-document
+        # val = { '$exists' => make_boolean(raw_val) }
+        bool = make_boolean(raw_val)
+        bool = !bool if field_node[:negate]
+        if bool
+          val = [
+            { key => { '$exists' => true } },
+            { key => { '$ne' => false } }
+          ]
+          key = '$and'
+        else
+          val = { '$exists' => false }
+        end
+      elsif type == String
+        if search_type == :quoted_str
+          val = /\b#{Regexp.escape(raw_val)}\b/
+        else
+          val = /#{Regexp.escape(raw_val)}/mi
+        end
+      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$/]
+          val = raw_val.to_f
+        else
+          val = raw_val
+        end
+      elsif type == Time
+        time_str = raw_val.tr('_.-', ' ')
+        date = Chronic.parse(time_str, guess: nil)
+        if field_node[:negate]
+          val = [
+            { key => { '$gt' => date.end   } },
+            { key => { '$lt' => date.begin } }
+          ]
+          key = '$or'
+        else
+          val = [
+            { key => { '$gte' => date.begin } },
+            { key => { '$lte' => date.end   } }
+          ]
+          key = '$and'
+        end
+      end
+
+      # regex (case insensitive probably best default, and let
+      # proper regex and alias support allow developers to have
+      # case sensitive if they want maybe.)
+
+      if field_node[:negate] && (type == Numeric || type == String)
+        { key => { '$not' => val } }
+      else
+        { key => val }
+      end
+    end
+
+    def build_compare(ast_node, command_types)
+      flip_ops = {
+        '<' => '>',
+        '>' => '<',
+        '<=' => '>=',
+        '>=' => '<='
+      }
+      reverse_ops = {
+        '<' => '>=',
+        '<=' => '>',
+        '>' => '<=',
+        '>=' => '<'
+      }
+      mongo_op_map = {
+        '<' => '$lt',
+        '>' => '$gt',
+        '<=' => '$lte',
+        '>=' => '$gte'
+      }
+
+      keys = command_types.keys
+      (first_node, last_node) = ast_node[:value]
+      key = first_node[:value]
+      val = last_node[:value]
+      op = ast_node[:nest_op]
+      op = reverse_ops[op] if first_node[:negate]
+
+      if keys.include?(val.to_sym)
+        (key, val) = [val, key]
+        op = flip_ops[op]
+      end
+
+      mongo_op = mongo_op_map[op]
+      raw_type = command_types[key.to_sym]
+
+      if raw_type.is_a?(Array)
+        type = (raw_type - [:allow_boolean]).first
+      else
+        type = raw_type
+      end
+
+      if command_types[val.to_sym]
+        val = '$' + val
+        key = '$' + key
+        val = [key, val]
+        key = '$expr'
+      elsif type == Numeric
+        if val == val.to_i.to_s
+          val = val.to_i
+        else
+          val = val.to_f
+        end
+      elsif type == Time
+        # foo <  day | day.start
+        # foo <= day | day.end
+        # foo >  day | day.end
+        # foo >= day | day.start
+        date_start_map = {
+          '<' => :start,
+          '>' => :end,
+          '<=' => :end,
+          '>=' => :start
+        }
+        date_pick = date_start_map[op]
+        time_str = val.tr('_.-', ' ')
+        date = Chronic.parse(time_str, guess: nil)
+        if date_pick == :start
+          val = date.first
+        elsif date_pick == :end
+          val = date.last
+        end
+      end
+      { key => { mongo_op => val } }
+    end
+
+    def build_searches(ast, fields, command_types)
+      ast.flat_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)
+          x
+        else
+          build_search(x, fields)
+        end
+      end
+    end
+
+    def build_tree(ast)
+      ast.flat_map do |x|
+        next x unless x[:nest_type]
+        mongo_types = { paren: '$and', pipe: '$or', minus: '$not' }
+        key = mongo_types[x[:nest_type]]
+        { key => build_tree(x[:value]) }
+      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 }
+      end
+    end
+
+    def decompose_nots(ast, not_depth = 0)
+      ast.flat_map do |x|
+        if x[:nest_type] == :minus
+          decompose_nots(x[:value], not_depth + 1)
+        elsif x[:nest_type]
+          x[:value] = decompose_nots(x[:value], not_depth)
+          x
+        else
+          x[:negate] = not_depth.odd?
+          x
+        end
+      end
+    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)
+      out = {} if out == []
+      out = out.first if out.count == 1
+      out = { '$and' => out } if out.count > 1
+      out
+    end
+  end
+end

data/lib/command_search/optimizer.rb

@@ -0,0 +1,84 @@
+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])
+        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
+      end
+    end
+
+    def negate_negate(ast)
+      ast.flat_map do |node|
+        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
+        node[:value].first[:value]
+      end
+    end
+
+    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
+        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
+      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".
+      out = ast
+      out = denest_parens(out)
+      out = negate_negate(out)
+      out = ands_and_ors(out)
+      out = remove_empty_strings(out)
+      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

@@ -0,0 +1,85 @@
+module CommandSearch
+  module Parser
+    module_function
+
+    def parens_rindex(input)
+      val_list = input.map { |x| x[:value] }
+      open_i = val_list.rindex('(')
+      return unless open_i
+      close_offset = val_list.drop(open_i).index(')')
+      return unless close_offset
+      [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 }
+      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!
+      # 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
+        front_offset = 0
+        front_offset = 1 if binary && i > 0
+        out[(i - front_offset)..(i + 1)] = {
+          type: :nest,
+          nest_type: type,
+          nest_op: out[i][:value],
+          value: val
+        }
+      end
+      out.map do |x|
+        next x unless x[:type] == :nest
+        x[:value] = cluster(type, x[:value], cluster_type)
+        x
+      end
+    end
+
+    def unchain(type, input)
+      input.each_index do |i|
+        front = input.dig(i, :type)
+        mid = input.dig(i + 1, :type)
+        back = input.dig(i + 2, :type)
+        if front == type && mid != type && back == type
+          input.insert(i + 1, input[i + 1])
+        end
+      end
+    end
+
+    def clean_ununused_syntax(input)
+      out = input.map do |x|
+        next if x[:type] == :paren && x[:value].is_a?(String)
+        if x[:nest_type] == :compare && x[:value].length < 2
+          x = clean_ununused_syntax(x[:value]).first
+        end
+        next x unless x && x[:type] == :nest
+        x[:value] = clean_ununused_syntax(x[:value])
+        x
+      end
+      out.compact
+    end
+
+    def parse(input)
+      out = input
+      out = group_parens(out)
+      out = cluster(:colon, out)
+      out = unchain(:compare, out)
+      out = cluster(:compare, out)
+      out = cluster(:minus, out, :prefix)
+      out = cluster(:pipe, out)
+      out = clean_ununused_syntax(out)
+      out
+    end
+  end
+end

data/lib/command_search.rb

@@ -0,0 +1,35 @@
+load(__dir__ + '/command_search/aliaser.rb')
+load(__dir__ + '/command_search/lexer.rb')
+load(__dir__ + '/command_search/parser.rb')
+load(__dir__ + '/command_search/command_dealiaser.rb')
+load(__dir__ + '/command_search/optimizer.rb')
+load(__dir__ + '/command_search/mongoer.rb')
+load(__dir__ + '/command_search/memory.rb')
+
+class Boolean; end
+
+module CommandSearch
+  module_function
+
+  def search(source, query, options = {})
+    aliases = options[:aliases] || {}
+    fields = options[:fields] || []
+    command_fields = options[:command_fields] || {}
+
+    aliased_query = Aliaser.alias(query, aliases)
+    tokens = Lexer.lex(aliased_query)
+    parsed = Parser.parse(tokens)
+    dealiased = CommandDealiaser.dealias(parsed, command_fields)
+    cleaned = CommandDealiaser.decompose_unaliasable(dealiased, command_fields)
+    opted = Optimizer.optimize(cleaned)
+
+    if source.respond_to?(:mongo_client) && source.queryable
+      fields = [:__CommandSearch_mongo_fields_dummy_key__] if fields.empty?
+      mongo_query = Mongoer.build_query(opted, fields, command_fields)
+      return source.where(mongo_query)
+    end
+
+    selector = Memory.build_query(opted, fields, command_fields)
+    source.select(&selector)
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: command_search
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- zumbalogy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-09-03 00:00:00.000000000 Z
+dependencies: []
+description: Query collections with ease and without an engine like Elasticsearch.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/command_search.rb
+- lib/command_search/aliaser.rb
+- lib/command_search/command_dealiaser.rb
+- lib/command_search/lexer.rb
+- lib/command_search/memory.rb
+- lib/command_search/mongoer.rb
+- lib/command_search/optimizer.rb
+- lib/command_search/parser.rb
+homepage: https://github.com/zumbalogy/command_search
+licenses:
+- Unlicense
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: A friendly search gem for users and developers.
+test_files: []