naranya_ecm-sdk 0.0.14 → 0.0.15

data/lib/naranya_ecm/search/query.rb

@@ -1,296 +1,295 @@
-module NaranyaEcm
-  module Search
-    class Query < Hash
-      class << self
-        def build_searchkick_like(term, options = {})
-          if term.is_a?(Hash)
-            options = term
-            term = nil
-          else
-            term = term.to_s
-          end
 
-          fields =
-            if options[:fields]
-              if options[:autocomplete]
-                options[:fields].map{|f| "#{f}.autocomplete" }
-              else
-                options[:fields].map do |value|
-                  k, v = value.is_a?(Hash) ? value.to_a.first : [value, :word]
-                  "#{k}.#{v == :word ? "analyzed" : v}"
-                end
-              end
+module NaranyaEcm::Search
+  class Query < Hash
+    class << self
+      def build_searchkick_like(term, options = {})
+        if term.is_a?(Hash)
+          options = term
+          term = nil
+        else
+          term = term.to_s
+        end
+
+        fields =
+          if options[:fields]
+            if options[:autocomplete]
+              options[:fields].map{|f| "#{f}.autocomplete" }
             else
-              ["_all"]
+              options[:fields].map do |value|
+                k, v = value.is_a?(Hash) ? value.to_a.first : [value, :word]
+                "#{k}.#{v == :word ? "analyzed" : v}"
+              end
             end
+          else
+            ["_all"]
+          end
 
-          operator = options[:partial] ? "or" : "and"
+        operator = options[:partial] ? "or" : "and"
 
-          # model and eagar loading
-          load = options[:load].nil? ? true : options[:load]
-          load = (options[:include] ? {include: options[:include]} : true) if load
+        # model and eagar loading
+        load = options[:load].nil? ? true : options[:load]
+        load = (options[:include] ? {include: options[:include]} : true) if load
 
-          # pagination
-          page = [options[:page].to_i, 1].max
-          per_page = (options[:limit] || options[:per_page] || 10).to_i
-          offset = options[:offset] || (page - 1) * per_page
+        # pagination
+        page = [options[:page].to_i, 1].max
+        per_page = (options[:limit] || options[:per_page] || 10).to_i
+        offset = options[:offset] || (page - 1) * per_page
 
-          all = term == "*"
+        all = term == "*"
 
-          if options[:query]
-            payload = options[:query]
-          elsif options[:similar]
+        if options[:query]
+          payload = options[:query]
+        elsif options[:similar]
+          payload = {
+            more_like_this: {
+              fields: fields,
+              like_text: term,
+              min_doc_freq: 1,
+              min_term_freq: 1,
+              analyzer: "searchkick_search2"
+            }
+          }
+        elsif all
+          payload = {
+            match_all: {}
+          }
+        else
+          if options[:autocomplete]
             payload = {
-              more_like_this: {
+              multi_match: {
                 fields: fields,
-                like_text: term,
-                min_doc_freq: 1,
-                min_term_freq: 1,
-                analyzer: "searchkick_search2"
+                query: term,
+                analyzer: "searchkick_autocomplete_search"
               }
             }
-          elsif all
-            payload = {
-              match_all: {}
-            }
           else
-            if options[:autocomplete]
-              payload = {
-                multi_match: {
-                  fields: fields,
+            queries = []
+            fields.each do |field|
+              if field == "_all" or field.end_with?(".analyzed")
+                shared_options = {
+                  fields: [field],
                   query: term,
-                  analyzer: "searchkick_autocomplete_search"
+                  use_dis_max: false,
+                  operator: operator,
+                  cutoff_frequency: 0.001
                 }
-              }
-            else
-              queries = []
-              fields.each do |field|
-                if field == "_all" or field.end_with?(".analyzed")
-                  shared_options = {
-                    fields: [field],
-                    query: term,
-                    use_dis_max: false,
-                    operator: operator,
-                    cutoff_frequency: 0.001
-                  }
+                queries.concat [
+                  {multi_match: shared_options.merge(boost: 10, analyzer: "searchkick_search")},
+                  {multi_match: shared_options.merge(boost: 10, analyzer: "searchkick_search2")}
+                ]
+                if options[:misspellings] != false
+                  distance = (options[:misspellings].is_a?(Hash) && options[:misspellings][:distance]) || 1
                   queries.concat [
-                    {multi_match: shared_options.merge(boost: 10, analyzer: "searchkick_search")},
-                    {multi_match: shared_options.merge(boost: 10, analyzer: "searchkick_search2")}
+                    {multi_match: shared_options.merge(fuzziness: distance, max_expansions: 3, analyzer: "searchkick_search")},
+                    {multi_match: shared_options.merge(fuzziness: distance, max_expansions: 3, analyzer: "searchkick_search2")}
                   ]
-                  if options[:misspellings] != false
-                    distance = (options[:misspellings].is_a?(Hash) && options[:misspellings][:distance]) || 1
-                    queries.concat [
-                      {multi_match: shared_options.merge(fuzziness: distance, max_expansions: 3, analyzer: "searchkick_search")},
-                      {multi_match: shared_options.merge(fuzziness: distance, max_expansions: 3, analyzer: "searchkick_search2")}
-                    ]
-                  end
-                else
-                  queries << {
-                    multi_match: {
-                      fields: [field],
-                      query: term,
-                      analyzer: "searchkick_autocomplete_search"
-                    }
-                  }
                 end
-              end
-
-              payload = {
-                dis_max: {
-                  queries: queries
+              else
+                queries << {
+                  multi_match: {
+                    fields: [field],
+                    query: term,
+                    analyzer: "searchkick_autocomplete_search"
+                  }
                 }
-              }
+              end
             end
 
+            payload = {
+              dis_max: {
+                queries: queries
+              }
+            }
           end
 
-          custom_filters = []
+        end
 
-          if options[:boost]
-            custom_filters << {
-              filter: {
-                exists: {
-                  field: options[:boost]
-                }
-              },
-              script: "log(doc['#{options[:boost]}'].value + 2.718281828)"
-            }
-          end
+        custom_filters = []
 
-          if custom_filters.any?
-            payload = {
-              custom_filters_score: {
-                query: payload,
-                filters: custom_filters,
-                score_mode: "total"
+        if options[:boost]
+          custom_filters << {
+            filter: {
+              exists: {
+                field: options[:boost]
               }
-            }
-          end
+            },
+            script: "log(doc['#{options[:boost]}'].value + 2.718281828)"
+          }
+        end
 
+        if custom_filters.any?
           payload = {
-            query: payload,
-            size: per_page,
-            from: offset
+            custom_filters_score: {
+              query: payload,
+              filters: custom_filters,
+              score_mode: "total"
+            }
           }
-          payload[:explain] = options[:explain] if options[:explain]
+        end
 
-          # order
-          if options[:order]
-            order = options[:order].is_a?(Enumerable) ? options[:order] : {options[:order] => :asc}
-            payload[:sort] = Hash[ order.map{|k, v| [k.to_s == "id" ? :_id : k, v] } ]
-          end
+        payload = {
+          query: payload,
+          size: per_page,
+          from: offset
+        }
+        payload[:explain] = options[:explain] if options[:explain]
 
-          term_filters =
-            proc do |field, value|
-              if value.is_a?(Array) # in query
-                if value.any?
-                  {or: value.map{|v| term_filters.call(field, v) }}
-                else
-                  {terms: {field => value}} # match nothing
-                end
-              elsif value.nil?
-                {missing: {"field" => field, existence: true, null_value: true}}
+        # order
+        if options[:order]
+          order = options[:order].is_a?(Enumerable) ? options[:order] : {options[:order] => :asc}
+          payload[:sort] = Hash[ order.map{|k, v| [k.to_s == "id" ? :_id : k, v] } ]
+        end
+
+        term_filters =
+          proc do |field, value|
+            if value.is_a?(Array) # in query
+              if value.any?
+                {or: value.map{|v| term_filters.call(field, v) }}
               else
-                {term: {field => value}}
+                {terms: {field => value}} # match nothing
               end
+            elsif value.nil?
+              {missing: {"field" => field, existence: true, null_value: true}}
+            else
+              {term: {field => value}}
             end
+          end
 
-          # where
-          where_filters =
-            proc do |where|
-              filters = []
-              (where || {}).each do |field, value|
-                field = :_id if field.to_s == "id"
+        # where
+        where_filters =
+          proc do |where|
+            filters = []
+            (where || {}).each do |field, value|
+              field = :_id if field.to_s == "id"
 
-                if field == :or
-                  value.each do |or_clause|
-                    filters << {or: or_clause.map{|or_statement| {and: where_filters.call(or_statement)} }}
-                  end
-                else
-                  # expand ranges
-                  if value.is_a?(Range)
-                    value = {gte: value.first, (value.exclude_end? ? :lt : :lte) => value.last}
-                  end
+              if field == :or
+                value.each do |or_clause|
+                  filters << {or: or_clause.map{|or_statement| {and: where_filters.call(or_statement)} }}
+                end
+              else
+                # expand ranges
+                if value.is_a?(Range)
+                  value = {gte: value.first, (value.exclude_end? ? :lt : :lte) => value.last}
+                end
 
-                  if value.is_a?(Hash)
-                    if value[:near]
-                      filters << {
-                        geo_distance: {
-                          field => value.delete(:near).map(&:to_f).reverse,
-                          distance: value.delete(:within) || "50mi"
-                        }
+                if value.is_a?(Hash)
+                  if value[:near]
+                    filters << {
+                      geo_distance: {
+                        field => value.delete(:near).map(&:to_f).reverse,
+                        distance: value.delete(:within) || "50mi"
                       }
-                    end
+                    }
+                  end
 
-                    if value[:top_left]
-                      filters << {
-                        geo_bounding_box: {
-                          field => {
-                            top_left: value.delete(:top_left).map(&:to_f).reverse,
-                            bottom_right: value.delete(:bottom_right).map(&:to_f).reverse
-                          }
+                  if value[:top_left]
+                    filters << {
+                      geo_bounding_box: {
+                        field => {
+                          top_left: value.delete(:top_left).map(&:to_f).reverse,
+                          bottom_right: value.delete(:bottom_right).map(&:to_f).reverse
                         }
                       }
-                    end
+                    }
+                  end
 
-                    value.each do |op, op_value|
-                      if op == :not # not equal
-                        filters << {not: term_filters.call(field, op_value)}
-                      elsif op == :all
-                        filters << {terms: {field => op_value, execution: "and"}}
-                      else
-                        range_query =
-                          case op
-                          when :gt
-                            {from: op_value, include_lower: false}
-                          when :gte
-                            {from: op_value, include_lower: true}
-                          when :lt
-                            {to: op_value, include_upper: false}
-                          when :lte
-                            {to: op_value, include_upper: true}
-                          else
-                            raise "Unknown where operator"
-                          end
-                        filters << {range: {field => range_query}}
-                      end
+                  value.each do |op, op_value|
+                    if op == :not # not equal
+                      filters << {not: term_filters.call(field, op_value)}
+                    elsif op == :all
+                      filters << {terms: {field => op_value, execution: "and"}}
+                    else
+                      range_query =
+                        case op
+                        when :gt
+                          {from: op_value, include_lower: false}
+                        when :gte
+                          {from: op_value, include_lower: true}
+                        when :lt
+                          {to: op_value, include_upper: false}
+                        when :lte
+                          {to: op_value, include_upper: true}
+                        else
+                          raise "Unknown where operator"
+                        end
+                      filters << {range: {field => range_query}}
                     end
-                  else
-                    filters << term_filters.call(field, value)
                   end
+                else
+                  filters << term_filters.call(field, value)
                 end
               end
-              filters
             end
-
-          # filters
-          filters = where_filters.call(options[:where])
-          if filters.any?
-            payload[:filter] = {
-              and: filters
-            }
+            filters
           end
 
-          # facets
-          facet_limits = {}
-          if options[:facets]
-            facets = options[:facets] || {}
-            if facets.is_a?(Array) # convert to more advanced syntax
-              facets = Hash[ facets.map{|f| [f, {}] } ]
-            end
+        # filters
+        filters = where_filters.call(options[:where])
+        if filters.any?
+          payload[:filter] = {
+            and: filters
+          }
+        end
 
-            payload[:facets] = {}
-            facets.each do |field, facet_options|
-              # ask for extra facets due to
-              # https://github.com/elasticsearch/elasticsearch/issues/1305
+        # facets
+        facet_limits = {}
+        if options[:facets]
+          facets = options[:facets] || {}
+          if facets.is_a?(Array) # convert to more advanced syntax
+            facets = Hash[ facets.map{|f| [f, {}] } ]
+          end
 
-              if facet_options[:ranges]
-                payload[:facets][field] = {
-                  range: {
-                    field.to_sym => facet_options[:ranges]
-                  }
+          payload[:facets] = {}
+          facets.each do |field, facet_options|
+            # ask for extra facets due to
+            # https://github.com/elasticsearch/elasticsearch/issues/1305
+
+            if facet_options[:ranges]
+              payload[:facets][field] = {
+                range: {
+                  field.to_sym => facet_options[:ranges]
                 }
-              else
-                payload[:facets][field] = {
-                  terms: {
-                    field: field,
-                    size: facet_options[:limit] ? facet_options[:limit] + 150 : 100000
-                  }
+              }
+            else
+              payload[:facets][field] = {
+                terms: {
+                  field: field,
+                  size: facet_options[:limit] ? facet_options[:limit] + 150 : 100000
                 }
-              end
+              }
+            end
 
-              facet_limits[field] = facet_options[:limit] if facet_options[:limit]
+            facet_limits[field] = facet_options[:limit] if facet_options[:limit]
 
-              # offset is not possible
-              # http://elasticsearch-users.115913.n3.nabble.com/Is-pagination-possible-in-termsStatsFacet-td3422943.html
+            # offset is not possible
+            # http://elasticsearch-users.115913.n3.nabble.com/Is-pagination-possible-in-termsStatsFacet-td3422943.html
 
-              facet_filters = where_filters.call(facet_options[:where])
-              if facet_filters.any?
-                payload[:facets][field][:facet_filter] = {
-                  and: {
-                    filters: facet_filters
-                  }
+            facet_filters = where_filters.call(facet_options[:where])
+            if facet_filters.any?
+              payload[:facets][field][:facet_filter] = {
+                and: {
+                  filters: facet_filters
                 }
-              end
+              }
             end
           end
+        end
 
-          # highlight
-          if options[:highlight]
-            payload[:highlight] = {
-              fields: Hash[ fields.map{|f| [f, {}] } ]
-            }
-            if options[:highlight].is_a?(Hash) and tag = options[:highlight][:tag]
-              payload[:highlight][:pre_tags] = [tag]
-              payload[:highlight][:post_tags] = [tag.to_s.gsub(/\A</, "</")]
-            end
+        # highlight
+        if options[:highlight]
+          payload[:highlight] = {
+            fields: Hash[ fields.map{|f| [f, {}] } ]
+          }
+          if options[:highlight].is_a?(Hash) and tag = options[:highlight][:tag]
+            payload[:highlight][:pre_tags] = [tag]
+            payload[:highlight][:post_tags] = [tag.to_s.gsub(/\A</, "</")]
           end
+        end
 
-          payload[:_source] = 'updated_at'
+        payload[:_source] = 'updated_at'
 
-          self.new.merge payload
-        end
+        self.new.merge payload
       end
     end
   end
-end
+end