generic_search 1.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7ea1f7c8f6d0091ee267fecfc54a5bbf4aaea91
+  data.tar.gz: 3594824bb78a70db17620bfffbd0347fd7c9173e
+SHA512:
+  metadata.gz: 00762261f46fd12bb1fe00aaaa9c21247c8846c9948e8b2e773a8b3928df63b1be0e7b9b55a0d6250630d0f05da9d90bd46b0bfee54440825984f4d44a9a1d59
+  data.tar.gz: f8bc639f68cedc7aac59fde4d5da387ddc62cf5c611fc22a7446511673c20b41e87644057efdacd6b3c1c07f2253ee90837a6f84baa4c78abb707a2811bab117

data/lib/generic_search/build_methods.rb

@@ -0,0 +1,297 @@
+module GenericSearch
+
+  #def self.custom_config
+  #  {
+  #      :transitions => {
+  #          :script_status => {
+  #              :field => :script_status_id,
+  #              :lambda => lambda do |operator, value|
+  #                Status.where("name #{operator} ?", value).collect(&:id)
+  #              end
+  #          }
+  #      }
+  #  }
+  #end
+
+  module BuildMethods
+
+    def build_where(query)
+
+      if query.blank?
+        return
+      end
+
+      query_table_list = []
+
+      query.each_line('),') do |segment|
+        segment.gsub!(/,$/, "")
+        query_table_list << segment
+      end
+
+      query_per_table = Array.new
+
+      @joins = []
+
+      query_table_list.each do |query_item|
+
+        table, search_params = query_item.to_s.split('(', 2)
+        table.strip!
+
+        column_names = []
+
+        if table.strip != @base_table
+          relation_name = @base_class._table_relation[table.strip]
+          @joins << relation_name if relation_name
+        end
+
+        search_params ||= ''
+        search_params.gsub!(/\)$/, "")
+
+        single_param_array = search_params.strip.split(/\s*,\s*/)
+        single_param_array_length = single_param_array.length
+
+        column_values = []
+        current_value = single_param_array[0]
+        i=0
+
+        until i >= single_param_array_length
+
+          next_value = single_param_array[i + 1]
+
+          if next_value.nil? or next_value.match(/([<>=!~]|between)/)
+            column_values << current_value
+            current_value = next_value
+          else
+            current_value << (',' + next_value)
+          end
+
+          i = i + 1
+        end
+
+        column_values.each do |search_param|
+          search_param.gsub!(/,$/, "")
+
+          if search_param.match(/(\w+)\s+between\s+(\*?.*)and(\*?.*)/i)
+            key, from, to = $1.strip, $2.strip, $3.strip
+
+            single_search_param = if from.match(/^\d+$/) and to.match(/^\d+$/)
+                                    "\"#{table}\".\"#{key}\" between #{from} and #{to}"
+                                  else
+                                    "\"#{table}\".\"#{key}\" between '#{from.to_time.to_s(:db)}' and '#{to.to_time.to_s(:db)}'"
+                                  end
+
+          else
+            search_param.match(/(\w+)(\s*[<>=!~]*\s*)(\*?.*)/)
+            key, operator, value = $1.strip, $2.strip, $3.strip
+
+            if operator == '='
+              if value.include? '*'
+                value.gsub!('*', '%')
+                value = "#{value}"
+                operator = 'ILIKE'
+                #elsif value.include? '/'
+                #  value = "(#{value})"
+                #  operator = 'in'
+                #elsif value.include? '|'
+                #  value = "(#{value})"
+                #  operator = 'in'
+                #else
+                #  value = "'#{value}'"
+              end
+
+            else
+              value = "#{value}"
+            end
+
+            config = GenericSearch.config[table.intern]
+            config = (config and config[:for_where])
+            key_intern = key.intern
+
+            #TODO: Test Requires
+            single_search_param = if config and config.has_key?(key_intern)
+                                    config = config[key_intern]
+                                    value = config[:lambda].call(operator, value)
+                                    #subQuery = value.is_a?(Array) ? "in (#{value.blank? ? 'NULL' : value.join(',')})" : "= '#{value}'"
+                                    subQuery = if value.is_a?(Array)
+                                                 if value.blank?
+                                                   "in (NULL)"
+                                                 else
+                                                   "in (#{value.join(',')})"
+                                                 end
+                                               else
+                                                 "= '#{value}'"
+                                               end
+                                    "\"#{table}\".\"#{config[:field]}\" #{subQuery}"
+                                  elsif operator == '=' and value.include?(',') or value.include?('|')
+
+                                    value = value.gsub(/\s*,\s*/, ' AND ').gsub(/\s*\|\s*/, ' OR ').split(/(AND|OR)/)
+                                    .collect do |val|
+                                      val.match(/(AND|OR)/) ? val : "\"#{table}\".\"#{key}\" #{operator} '#{val.strip}'"
+                                    end.join(' ')
+
+                                    "(#{value})"
+
+                                  else
+                                    "\"#{table}\".\"#{key}\" #{operator} '#{value}'"
+                                  end
+
+            column_names << key
+          end
+
+          query_per_table << single_search_param
+        end
+
+        self.validate_columns(table, column_names, :query)
+      end
+
+      self.where = query_per_table.join(' AND ')
+    end
+
+    def build_results(results)
+      table_selected_fields = {}
+
+      selects = if results.blank?
+                  [self.base_class.table_name]
+                else
+                  selects = results.scan(/\w+\(.*?\)/)
+                  results_clone = results.clone
+
+                  selects.each do |select|
+                    results_clone.gsub!(select, '')
+                  end
+
+                  selects += results_clone.split(/,/).delete_if(&:blank?)
+                  selects
+                end
+
+      selects.each do |select|
+        match, table, select_fields = *select.match(/(\w+)\(*([\s\w,]*)\)*/)
+        table_selected_fields[table] = select_fields.blank? ? nil : select_fields.strip.split(/\s*,\s*/)
+      end
+
+      table_selected_fields.each do |table_name, column_names|
+        validate_columns(table_name, column_names, :results)
+      end
+
+      #TODO: self.select = table_selected_fields.clone
+      self.select = table_selected_fields
+    end
+
+    def build_group(group)
+
+      if group.blank?
+        return
+      end
+
+      group_entities = group.scan(/\w+\(.*?\)/)
+
+      @joins ||= []
+      group_table_fields_map = {}
+      @group = []
+      @group_object_access = []
+
+      group_entities.each do |group_entity|
+        match, table, select_fields = *group_entity.match(/(\w+)\(*([\s\w,]*)\)*/)
+        table.strip!
+        fields = select_fields.split(/\s*,\s*/)
+        group_table_fields_map[table] = fields
+
+        #@joins << @base_class._table_relation[table.strip] if table != @base_class.table_name
+
+        table.strip!
+        if table != @base_table
+          relation_name = (@base_class._table_relation[table] || (@base_class._relation_table[table.intern] ? table.intern : nil))
+          table_name = @base_class._table_relation[table] ? table : @base_class._relation_table[table.intern]
+          @joins << relation_name if relation_name
+        else
+          table_name = table
+        end
+
+        fields.each do |field|
+          @group << "#{table_name}.#{field}"
+          #@group_object_access << (@base_table == table ? field : "#{@base_class._table_relation[table]}.#{field}")
+          @group_object_access << (@base_table == table_name ? field : "#{relation_name}.#{field}")
+        end
+      end
+
+      group_table_fields_map.each do |table, column_names|
+        validate_columns(table, column_names, :group)
+      end
+
+
+    end
+
+    def build_sort_order(sort_order)
+      self.sort_order = if sort_order.nil?
+                          "\"#{self.base_table}\".\"id\" ASC"
+                        elsif sort_order.strip == "\"\"" || sort_order.strip == "\'\'" || sort_order.strip == ''
+                          nil
+                        else
+                          sort_order.strip
+                        end
+    end
+
+    def build_limit(limit)
+      #TODO: Test required for group.blank?
+      if self.options[:no_results] or !self.group.blank?
+        self.limit = nil
+      else
+        self.limit = limit.blank? ? GenericSearch::DEFAULT_LIMIT : limit
+      end
+
+    end
+
+    def build_start(start)
+      #TODO: Test required for group.blank?
+      self.start = if self.options[:no_results] or !self.group.blank?
+                     nil
+                   else
+                     start.blank? ? 0 : start
+                   end
+    end
+
+    # options = no_results, no_limit_count
+    def build_options(options)
+
+      self.options = {}
+
+      return if options.blank?
+
+      if options.include? 'no_results'
+        self.options[:no_results] = true
+      end
+
+      if options.include? 'no_limit_count'
+        self.options[:no_limit_count] = true
+      end
+
+      if options.include? 'distinct'
+        self.options[:distinct] = true
+      end
+
+    end
+
+    def build_response
+
+      self.response = {
+          :success => self.status == :ok ? true : false,
+          :code => self.status == :ok ? 200 : 400,
+          :status => self.status,
+          :message => self.messages,
+          :client_IP => nil,
+          :controller => nil,
+
+          :server => Socket.gethostname,
+          :where_clause => self.where,
+          :no_limit_result_count => self.no_limit_count,
+          :limit_result_count => self.limit_result_count,
+          :timestamp => Time.now,
+          :groups => self.grouped_results
+          #"groups" => params.has_key?(:no_results) ? [] : @grouped_results
+      }
+
+    end
+
+  end
+
+end

data/lib/generic_search/config.rb

@@ -0,0 +1,4 @@
+module GenericSearch
+  #DEFAULT_LIMIT = 1000
+  DEFAULT_LIMIT = nil
+end

data/lib/generic_search/exception.rb

@@ -0,0 +1,5 @@
+module GenericSearch
+  class UnknownInputType < Exception
+
+  end
+end

data/lib/generic_search/messages.rb

@@ -0,0 +1,8 @@
+module GenericSearch
+  module Messages
+    DoubleCloseParan = 'malformed url - double close paren'
+    IncorrectUseOfParan = 'malformed url - incorrect use of parentheses'
+    DoubleOpenParan = 'malformed url - double open paren'
+    DoubleComma = "malformed url - double comma"
+  end
+end

data/lib/generic_search/rails_overrides.rb

@@ -0,0 +1,62 @@
+class ActiveRecord::Base
+
+  def _generic_search(args)
+    if args.is_a? HashWithIndifferentAccess or args.is_a? Hash
+      generic_search = GenericSearch::Klass.new(args, self.class)
+      generic_search.search
+    elsif args.is_a? GenericSearch
+
+    else
+      raise UnknownInputType
+    end
+
+  end
+
+  def self.generic_search config
+    GenericSearch.update_config(self.table_name, config[:custom_attributes])
+  end
+
+  def self._table_relation
+    #@@table_relation ||= begin
+    #  puts "processing..."
+    self.reflect_on_all_associations.inject({}) do |hash, assoc_reflection|
+      hash[assoc_reflection.table_name] ||= assoc_reflection.name
+      hash
+    end
+    #end
+  end
+
+  def self._relation_table
+    #@@relation_table ||= begin
+    #puts "processing..."
+    self.reflect_on_all_associations.inject({}) do |hash, assoc_reflection|
+      hash[assoc_reflection.name] ||= assoc_reflection.table_name
+      hash
+    end
+    #end
+  end
+
+end
+
+#class ApplicationController
+#
+#  def _generic_search
+#    base_class = self.class.to_s.gsub('Controller', '').singularize.constantize
+#    generic_search = GenericSearch::Klass.new(params, base_class)
+#    generic_search.search
+#    response = generic_search.response
+#
+#    response[:client_IP] = self.request.headers["X-Cluster-Client-Ip"]
+#    response[:controller] = controller_name.classify.to_s
+#
+#    render :json => generic_search.response
+#  end
+#
+#  # Restrictions to the controller
+#  # generic_search_config(false) # to disable the generic search in a controller
+#  # generic_search_config(:model_class => Script) # to disable the generic search in a controller
+#  def self.generic_search_config(restrictions)
+#    # Restriction logic for controller
+#  end
+#
+#end

data/lib/generic_search/validation.rb

@@ -0,0 +1,181 @@
+module GenericSearch
+
+  module Validation
+
+    def validate
+
+    end
+
+    def validate_syntax
+
+      [params[:query], params[:results], params[:group]].each do |query_string|
+
+        next if query_string.blank?
+
+        #if query_string.include?(',,')
+        if query_string.match(/\s*\,\s*\,\s*/)
+          @status = :bad_request
+          #@message = "malformed url - double comma"
+          @message = GenericSearch::Messages::DoubleComma
+          self.errors.add(:base, @message)
+          #return false
+        end
+
+        #if query_string.include?('((')
+        if query_string.match(/\s*\(\s*\(\s*/)
+          @status = :bad_request
+          @message = GenericSearch::Messages::DoubleOpenParan
+          self.errors.add(:base, @message)
+          #return false
+        end
+
+        # To check ))
+        if query_string.match(/\s*\)\s*\)\s*/)
+          @status = :bad_request
+          @message = GenericSearch::Messages::DoubleCloseParan
+          self.errors.add(:base, @message)
+        end
+
+        if query_string.count("()") % 2 == 1
+          @status = :bad_request
+          @message = GenericSearch::Messages::IncorrectUseOfParan
+          self.errors.add(:base, @message)
+        end
+      end
+
+      #if type.eql?("where_clause")
+      #  puts "verifying specific legal query_strings for where_clause"
+      #  if !query_string.include?('(')
+      #    @status = :bad_request
+      #    @message = "malformed url - no query arguments"
+      #    return false
+      #  end
+      #end
+
+      #return true
+    end
+
+    #def validate_table_columns
+    #
+    #  #self.validate_query
+    #
+    #end
+
+    def validate_columns(table_name, column_names, clause)
+
+      connection = ActiveRecord::Base.connection
+      config = GenericSearch.config[table_name.intern]
+      config_for_where = (config and config[:for_where]) || {}
+      config_for_select = (config and config[:for_select]) || {}
+
+      if !connection.table_exists?(table_name) and !self.base_class.reflections.has_key?(table_name)
+        self.errors.add(:base, "'#{table_name}' table is invalid (in '#{clause}')")
+        return
+      end
+
+      if !connection.table_exists?(table_name)
+        if !self.base_class.reflections.has_key?(table_name)
+          self.errors.add(:base, "'#{table_name}' table is invalid (in '#{clause}')")
+          return
+        else
+          table_name = self.base_class._relation_table[table_name.intern]
+        end
+      end
+
+      return if column_names.blank?
+
+      unknown_columns = []
+
+      column_names.each do |column_name|
+        next if config_for_select and config_for_select.has_key?(column_name.intern)
+        next if config_for_where and config_for_where.has_key?(column_name.intern)
+
+        if !connection.column_exists?(table_name, column_name) and !config_for_select.has_key?(column_name.intern) and !config_for_where.has_key?(column_name.intern)
+          unknown_columns << column_name
+        end
+      end
+
+      if !unknown_columns.blank?
+        self.errors.add(:base, "'#{unknown_columns.join(', ')}' column#{unknown_columns.size > 1 ? 's' : ''} not found in '#{table_name}' table (in '#{clause}')")
+      end
+
+    end
+
+    def valid_syntax?(query_string)
+
+    end
+
+    def validate_query
+
+    end
+
+    def validate_results
+
+    end
+
+    def validate_group
+
+    end
+
+    def validate_sort_order
+
+    end
+
+    def validate_limit
+
+    end
+
+    #def validate_columns(table_name, column_names, clause)
+    #
+    #  connection = ActiveRecord::Base.connection
+    #
+    #  if !connection.table_exists?(table_name) and !self.base_class.reflections.has_key?(table_name.intern)
+    #    @_uri_errors << "'#{table_name}' is invalid in '#{clause}'"
+    #    return
+    #  end
+    #
+    #  if !connection.table_exists?(table_name)
+    #    if !self.base_class.reflections.has_key?(table_name.intern)
+    #      @_uri_errors << "'#{table_name}' is invalid in '#{clause}'"
+    #      return
+    #    else
+    #      table_name = self.base_class._relation_table[table_name.intern]
+    #    end
+    #  end
+    #
+    #  return if column_names.blank?
+    #
+    #  unknown_columns = []
+    #
+    #  config = GenericSearchMethods.config[table_name.intern]
+    #  column_names.each do |column_name|
+    #
+    #    next if config and config.has_key?(column_name.intern)
+    #
+    #    if !connection.column_exists?(table_name, column_name)
+    #      unknown_columns << column_name
+    #    end
+    #  end
+    #
+    #  if !unknown_columns.blank?
+    #    @_uri_errors << "'#{unknown_columns.join(', ')}' column#{unknown_columns.size > 1 ? 's' : ''} not found in '#{table_name}' table in '#{clause}'"
+    #  end
+    #
+    #end
+
+    def validate_table_columns(table, columns)
+      #connection = ActiveRecord::Base.connection
+
+      #if connection.table_exists? table
+      #
+      #end
+
+    end
+
+    def validate_uri_syntax
+
+    end
+
+  end
+
+end

data/lib/generic_search/version.rb

@@ -0,0 +1,3 @@
+module GenericSearch
+  VERSION = "1.3.2"
+end

data/lib/generic_search.rb

@@ -0,0 +1,201 @@
+require 'active_record'
+require 'generic_search/validation'
+require 'generic_search/build_methods'
+require 'generic_search/config'
+require 'generic_search/exception'
+require 'generic_search/rails_overrides'
+require 'generic_search/validation'
+require 'generic_search/messages'
+
+module GenericSearch
+
+  @@generic_search = {
+      :config => {}
+  }
+
+  def self.update_config(class_name, config)
+    @@generic_search[:config][class_name.intern] = config
+  end
+
+  def self.config
+    @@generic_search[:config]
+  end
+
+  class Klass
+    include ActiveModel::Validations
+    include GenericSearch::Validation
+    include GenericSearch::BuildMethods
+
+    # Clause attributes
+    attr_accessor :where, :includes, :joins, :select, :group, :limit, :start, :sort_order, :options
+
+    # Utility attributes
+    attr_accessor :base_class, :base_table, :grouped_results, :params
+
+    # Output attributes
+    attr_accessor :status, :messages, :response, :results, :no_limit_count, :limit_result_count
+
+    validate :validate_syntax
+
+    # ===== To configure generic search in model =====
+    #generic_search_config {
+    #  table_alias: {
+    #      transitions: transition
+    #  }
+    #}
+    # ===== To configure generic search in model =====
+
+
+    # ==== Hash Inputs: ===
+    #{
+    #    :query => "responsibles(username=ksmanoj)",
+    #    :results => "scripts(id, name), responsibles",
+    #    :limit => 5,
+    #    :options => "no_results"
+    #}
+    def initialize(params, base_class)
+
+      self.base_class = base_class.is_a?(String) ? base_class.constantize : base_class
+      self.base_table = self.base_class.table_name
+
+      unless params.is_a?(Hash) or params.is_a?(HashWithIndifferentAccess)
+        raise GenericSearch::UnknownInputType
+      end
+
+      self.params = params
+
+      self.validate_syntax
+
+      return unless self.errors.blank?
+
+      self.build_where(params[:query])
+      self.build_results(params[:results])
+      self.build_group(params[:group])
+      self.build_options(params[:options])
+      self.build_limit(params[:limit])
+      self.build_start(params[:start])
+      self.build_sort_order(params[:sort_order])
+
+    end
+
+    def search
+
+      unless self.errors.blank?
+        self.status = :bad_request
+        self.messages = self.errors.full_messages
+        self.build_response
+        return self.response
+      end
+
+      table_relation_map = self.base_class._table_relation
+      relation_table_map = self.base_class._relation_table
+
+      includes = Hash.new
+      json_includes = Hash.new
+
+      self.select.each do |table, value|
+        table = table.strip
+        relationship_name = table_relation_map[table]
+        relationship_name = table.intern if !relationship_name or relation_table_map[table.intern]
+        includes[relationship_name] = {} if table != self.base_table
+        json_includes[relationship_name] = {:only => self.select[table]} if table != self.base_table
+      end
+
+      # TODO: Solve n+1 issue for custom columns
+      #config = GenericSearch.config[self.base_table.intern][:for_select]
+      #selected_fields = table_selected_fields[self.base_table]
+      #
+      #config.each do |custom_column, attrs|
+      #  if attrs[:include] and selected_fields.include?(custom_column.to_s)
+      #    selected_fields << attrs[:include]
+      #  end
+      #end
+      #
+
+      self.results = self.base_class.where(self.where).joins(self.joins).includes(self.includes).order(self.sort_order)
+
+      #result_list = @model_class.joins(@joins).includes(includes).where(@where_clause).distinct
+
+      # TODO: Test required
+      if self.options[:distinct]
+        self.results = self.results.uniq
+      end
+
+      # ========== Limiting & Grouping =========
+      # TODO: If there is a limit then only following count query has to be executed otherwise use .length
+      if self.options[:no_limit_count]
+        # Note: If no limit or start, then .length will fire the query, from that length is calculated.
+        # Additional count query is not required
+        self.no_limit_count = (self.limit || self.start) ? self.results.count : self.results.length
+        #self.no_limit_count = self.results.count
+      end
+
+      # TODO: Test required
+      unless self.options[:no_results]
+        self.results = self.results.limit(self.limit).offset(self.start)
+      end
+
+      # TODO: Test required
+      if self.group
+        group_result_counts = self.results.group(self.group).count
+      end
+
+      # ============== Group result processing
+      # TODO: Test required
+      if group_result_counts
+        # Hack to dynamically group the array of objects
+        eval_str = @group_object_access.collect { |i| "result.#{i}.to_s" }.join(' + ')
+        grouped_result = self.results.group_by { |result| eval eval_str }
+
+        group_hsh = group_result_counts.collect do |values, group_result_count|
+
+          values = values.is_a?(Array) ? values.collect(&:to_s) : [values.to_s]
+          result_key = values.join('')
+
+          results = if self.options[:no_results]
+                      []
+                    else
+                      #grouped_result[result_key].as_json(:include => json_includes, :only => @table_selected_fields[self.base_table])
+                      grouped_result[result_key].as_json(:include => json_includes, :only => self.select[self.base_table], :methods => self.select[self.base_table])
+                    end
+
+          {
+              :group_by_field => self.group.join(', '),
+              :group_by_value => values.join(','),
+              :num_results => group_result_count,
+              #:results => grouped_result[result_key]
+              :results => results
+          }
+        end
+      else
+
+        results = if self.options[:no_results]
+                    []
+                  else
+
+                    #self.results.as_json(:include => json_includes, :only => @table_selected_fields[self.base_table])
+                    #self.results.as_json(:include => json_includes, :only => self.select[self.base_table], :methods => [:address_ids])
+                    self.results.as_json(:include => json_includes, :only => self.select[self.base_table], :methods => self.select[self.base_table])
+                  end
+
+        group_hsh = [{:num_results => self.results.length, :results => results}]
+
+      end
+
+      self.grouped_results = group_hsh
+
+      limit_result_count = 0
+
+      self.grouped_results.each do |grouped_result|
+        #limit_result_count += grouped_result["results"].count
+        limit_result_count += grouped_result[:num_results]
+      end
+
+      self.limit_result_count = limit_result_count
+      self.status = :ok
+      self.build_response
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: generic_search
+version: !ruby/object:Gem::Version
+  version: 1.3.2
+platform: ruby
+authors:
+- Justin Hayes
+- Manoj
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Search any data from database without writing any code.
+email:
+- jhayes@juniper.net
+- ksmanoj@juniper.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generic_search.rb
+- lib/generic_search/build_methods.rb
+- lib/generic_search/config.rb
+- lib/generic_search/exception.rb
+- lib/generic_search/messages.rb
+- lib/generic_search/rails_overrides.rb
+- lib/generic_search/validation.rb
+- lib/generic_search/version.rb
+homepage: https://rubygems.org/bethink/generic_search
+licenses:
+- MIT
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Search any data from database without writing any code.
+test_files: []