search_flip 1.0.0

data/lib/search_flip/filterable.rb

@@ -0,0 +1,240 @@
+
+module SearchFlip
+  # The SearchFlip::Filterable mixin provides chainable methods like
+  # #where, #exists, #range, etc to add search filters to a criteria.
+  #
+  # @example
+  #   CommentIndex.where(public: true)
+  #   CommentIndex.exists(:user_id)
+  #   CommentIndex.range(:created_at, gt: Date.today - 7)
+
+  module Filterable
+    def self.included(base)
+      base.class_eval do
+        attr_accessor :search_values, :must_values, :must_not_values, :should_values, :filter_values
+      end
+    end
+
+    # Adds a query string query to the criteria while using AND as the default
+    # operator unless otherwise specified. Check out the ElasticSearch docs
+    # for further details.
+    #
+    # @example
+    #   CommentIndex.search("message:hello OR message:worl*")
+    #
+    # @param q [String] The query string query
+    #
+    # @param options [Hash] Additional options for the query string query, like
+    #   eg default_operator, default_field, etc.
+    #
+    # @return [SearchFlip::Criteria] A newly created extended criteria
+
+    def search(q, options = {})
+      fresh.tap do |criteria|
+        criteria.search_values = (search_values || []) + [query_string: { query: q, :default_operator => :AND }.merge(options)] if q.to_s.strip.length > 0
+      end
+    end
+
+    # Adds filters to your criteria for the supplied hash composed of
+    # field-to-filter mappings which specify terms, term or range filters,
+    # depending on the type of the respective hash value, namely array, range
+    # or scalar type like Fixnum, String, etc.
+    #
+    # @example
+    #   CommentIndex.where(id: [1, 2, 3], state: ["approved", "declined"])
+    #   CommentIndex.where(id: 1 .. 100)
+    #   CommentIndex.where(created_at: Time.parse("2016-01-01") .. Time.parse("2017-01-01"))
+    #   CommentIndex.where(id: 1, message: "hello")
+    #   CommentIndex.where(state: nil)
+    #
+    # @param hash [Hash] A field-to-filter mapping specifying filter values for
+    #   the respective fields
+    #
+    # @return [SearchFlip::Criteria] A newly created extended criteria
+
+    def where(hash)
+      hash.inject(fresh) do |memo, (key, value)|
+        if value.is_a?(Array)
+          memo.filter terms: { key => value }
+        elsif value.is_a?(Range)
+          memo.filter range: { key => { gte: value.min, lte: value.max } }
+        elsif value.nil?
+          memo.exists_not key
+        else
+          memo.filter term: { key => value }
+        end
+      end
+    end
+
+    # Adds filters to exclude documents in accordance to the supplied hash
+    # composed of field-to-filter mappings. Check out #where for further
+    # details.
+    #
+    # @see #where See #where for further details
+    #
+    # @example
+    #   CommentIndex.where_not(state: "approved")
+    #   CommentIndex.where_not(created_at: Time.parse("2016-01-01") .. Time.parse("2017-01-01"))
+    #   CommentIndex.where_not(id: [1, 2, 3], state: "new")
+    #   CommentIndex.where_not(state: nil)
+    #
+    # @param hash [Hash] A field-to-filter mapping specifying filter values for the
+    #   respective fields
+    #
+    # @return [SearchFlip::Criteria] A newly created extended criteria
+
+    def where_not(hash)
+      hash.inject(fresh) do |memo, (key, value)|
+        if value.is_a?(Array)
+          memo.must_not terms: { key => value }
+        elsif value.is_a?(Range)
+          memo.must_not range: { key => { gte: value.min, lte: value.max } }
+        elsif value.nil?
+          memo.exists key
+        else
+          memo.must_not term: { key => value }
+        end
+      end
+    end
+
+    # Adds raw filter queries to the criteria.
+    #
+    # @example
+    #   CommentIndex.filter(term: { state: "new" })
+    #   CommentIndex.filter(range: { created_at: { gte: Time.parse("2016-01-01") }})
+    #
+    # @param args [Array, Hash] The raw filter query arguments
+    #
+    # @return [SearchFlip::Criteria] A newly created extended criteria
+
+    def filter(*args)
+      fresh.tap do |criteria|
+        criteria.filter_values = (filter_values || []) + args
+      end
+    end
+
+    # Adds raw must queries to the criteria.
+    #
+    # @example
+    #   CommentIndex.must(term: { state: "new" })
+    #   CommentIndex.must(range: { created_at: { gt: Time.parse("2016-01-01") }})
+    #
+    # @param args [Array, Hash] The raw must query arguments
+    #
+    # @return [SearchFlip::Criteria] A newly created extended criteria
+
+    def must(*args)
+      fresh.tap do |criteria|
+        criteria.must_values = (must_values || []) + args
+      end
+    end
+
+    # Adds raw must_not queries to the criteria.
+    #
+    # @example
+    #   CommentIndex.must_not(term: { state: "new" })
+    #   CommentIndex.must_not(range: { created_at: { gt: Time.parse"2016-01-01") }})
+    #
+    # @param args [Array, Hash] The raw must_not query arguments
+    #
+    # @return [SearchFlip::Criteria] A newly created extended criteria
+
+    def must_not(*args)
+      fresh.tap do |criteria|
+        criteria.must_not_values = (must_not_values || []) + args
+      end
+    end
+
+    # Adds raw should queries to the criteria.
+    #
+    # @example
+    #   CommentIndex.should(term: { state: "new" })
+    #   CommentIndex.should(range: { created_at: { gt: Time.parse"2016-01-01") }})
+    #
+    # @param args [Array, Hash] The raw should query arguments
+    #
+    # @return [SearchFlip::Criteria] A newly created extended criteria
+
+    def should(*args)
+      fresh.tap do |criteria|
+        criteria.should_values = (should_values || []) + args
+      end
+    end
+
+    # Adds a range filter to the criteria without being forced to specify the
+    # left and right end of the range, such that you can eg simply specify lt,
+    # lte, gt and gte. For fully specified ranges, you can as well use #where,
+    # etc. Check out the ElasticSearch docs for further details regarding the
+    # range filter.
+    #
+    # @example
+    #   CommentIndex.range(:created_at, gte: Time.parse("2016-01-01"))
+    #   CommentIndex.range(:likes_count, gt: 10, lt: 100)
+    #
+    # @param field [Symbol, String] The field name to specify the range for
+    # @param options [Hash] The range filter specification, like lt, lte, etc
+    #
+    # @return [SearchFlip::Criteria] A newly created extended criteria
+
+    def range(field, options = {})
+      filter range: { field => options }
+    end
+
+    # Adds a match all filter/query to the criteria, which simply matches all
+    # documents. This can be eg be used within filter aggregations or for
+    # filter chaining. Check out the ElasticSearch docs for further details.
+    #
+    # @example Basic usage
+    #   CommentIndex.match_all
+    #
+    # @example Filter chaining
+    #   query = CommentIndex.match_all
+    #   query = query.where(public: true) unless current_user.admin?
+    #
+    # @example Filter aggregation
+    #   query = CommentIndex.aggregate(filtered_tags: {}) do |aggregation|
+    #     aggregation = aggregation.match_all
+    #     aggregation = aggregation.where(user_id: current_user.id) if current_user
+    #     aggregation = aggregation.aggregate(:tags)
+    #   end
+    #
+    #   query.aggregations(:filtered_tags).tags.buckets.each { ... }
+    #
+    # @param options [Hash] Options for the match_all filter, like eg boost
+    #
+    # @return [SearchFlip::Criteria] A newly created extended criteria
+
+    def match_all(options = {})
+      filter match_all: options
+    end
+
+    # Adds an exists filter to the criteria, which selects all documents for
+    # which the specified field has a non-null value.
+    #
+    # @example
+    #   CommentIndex.exists(:notified_at)
+    #
+    # @param field [Symbol, String] The field that should have a non-null value
+    #
+    # @return [SearchFlip::Criteria] A newly created extended criteria
+
+    def exists(field)
+      filter exists: { field: field }
+    end
+
+    # Adds an exists not filter to the criteria, which selects all documents
+    # for which the specified field's value is null.
+    #
+    # @example
+    #   CommentIndex.exists_not(:notified_at)
+    #
+    # @param field [Symbol, String] The field that should have a null value
+    #
+    # @return [SearchFlip::Criteria] A newly created extended criteria
+
+    def exists_not(field)
+      must_not exists: { field: field }
+    end
+  end
+end
+

data/lib/search_flip/http_client.rb

@@ -0,0 +1,49 @@
+
+module SearchFlip
+  # @api private
+  #
+  # The SearchFlip::HTTPClient class wraps the http gem, is for internal use
+  # and responsible for the http request/response handling, ie communicating
+  # with ElasticSearch.
+
+  class HTTPClient
+    class Request
+      attr_accessor :headers_hash
+
+      def headers(hash = {})
+        dup.tap do |request|
+          request.headers_hash = (request.headers_hash || {}).merge(hash)
+        end
+      end
+
+      [:get, :post, :put, :delete, :head].each do |method|
+        define_method method do |*args|
+          execute(method, *args)
+        end
+      end
+
+      private
+
+      def execute(method, *args)
+        response = HTTP.headers(headers_hash || {}).send(method, *args)
+
+        raise SearchFlip::ResponseError.new(code: response.code, body: response.body.to_s) unless response.status.success?
+
+        response
+      rescue HTTP::ConnectionError => e
+        raise SearchFlip::ConnectionError, e.message
+      end
+    end
+
+    def self.request
+      Request.new
+    end
+
+    class << self
+      extend Forwardable
+
+      def_delegators :request, :headers, :get, :post, :put, :delete, :head
+    end
+  end
+end
+