elasticsearch-persistence-queryable 0.1.8

data/lib/elasticsearch/persistence/relation/query_builder.rb

@@ -0,0 +1,279 @@
+module Elasticsearch
+  module Persistence
+    class QueryBuilder
+
+      attr_reader :structure, :values
+
+      def initialize(values)
+        @values = values
+      end
+
+      def aggregations
+        values[:aggregation]
+      end
+
+      def filters
+        values[:filter]
+      end
+
+      def or_filters
+        values[:or_filter]
+      end
+
+      def query
+        @query ||= compact_where(values[:where])
+      end
+
+      def query_strings
+        @query_string ||= compact_where(values[:query_string], bool: false)
+      end
+
+      def must_nots
+        @must_nots ||= compact_where(values[:must_not])
+      end
+
+      def shoulds
+        @shoulds ||= compact_where(values[:should])
+      end
+
+      def fields
+        values[:field]
+      end
+
+      def source
+        values[:source]
+      end
+
+      def highlights
+        values[:highlight]
+      end
+
+      def size
+        values[:size]
+      end
+
+      def sort
+        values[:order]
+      end
+
+      def query_filters
+        values[:filter]
+      end
+
+      def search_options
+        build_search_options
+      end
+
+      def query_string_options
+        @query_string_options || {}
+      end
+
+      def count?
+        values[:count]
+      end
+
+      def to_elastic
+        @structure = Jbuilder.new ignore_nil: true
+        build_query
+        build_sort unless sort.blank?
+        build_highlights unless highlights.blank?
+        build_fields unless fields.blank?
+        build_source unless source.blank?
+        build_aggregations unless aggregations.blank?
+        structure.attributes!
+      end
+
+      private
+
+      def missing_bool_query?
+        query.nil? && must_nots.nil? && shoulds.nil?
+      end
+
+      def missing_query_string?
+        query_strings.nil?
+      end
+
+      def missing_query_filter?
+        query_filters.nil? && or_filters.nil?
+      end
+
+      def build_query
+        return if missing_bool_query? && missing_query_string? && missing_query_filter?
+        structure.query do
+          structure.bool do
+                structure.must query unless missing_bool_query?
+                structure.must_not must_nots unless must_nots.nil?
+                structure.should shoulds unless shoulds.nil?
+
+            build_filtered_query if query_filters || or_filters
+
+          end unless missing_bool_query? && missing_query_filter?
+
+
+          structure.query_string do
+            structure.extract! query_string_options, *query_string_options.keys
+            structure.query query_strings
+          end unless query_strings.nil?
+        end
+      end
+
+      def build_filtered_query
+        structure.filter do
+          structure.or do
+            or_filters.each do |f|
+              structure.child! do
+                structure.set! f[:name], extract_filters(f[:name], f[:args])
+              end
+            end
+          end unless or_filters.blank?
+
+          structure.bool do
+            structure.must do
+              query_filters.each do |f|
+                structure.child! do
+                  structure.set! f[:name], extract_filters(f[:name], f[:args])
+                end
+              end
+            end
+          end unless query_filters.blank?
+        end
+      end
+
+      def build_source
+        if [true,false].include? source.first
+          structure._source source.first
+        else
+          structure._source do
+              structure.include source.first.delete(:include) if source.first.has_key? :include
+              structure.exclude source.first.delete(:exclude) if source.first.has_key? :exclude
+          end
+        end
+      end
+
+      def build_sort
+        structure.sort sort.flatten.inject(Hash.new) { |h,v| h.merge(v) }
+      end
+
+      def build_highlights
+        structure.highlight do
+          structure.fields do
+            highlights.each do |highlight|
+              structure.set! highlight, extract_highlighter(highlight)
+            end
+          end
+        end
+      end
+
+      def build_filters
+        filters.each do |f|
+          structure.filter extract_filters(f[:name], f[:args])
+        end
+      end
+
+      def build_or_filters
+        or_filters.each do |f|
+          structure.filter extract_filters(f[:name], f[:args])
+        end
+      end
+
+      def build_aggregations
+        structure.aggregations do
+          aggregations.each do |agg|
+            structure.set! agg[:name], aggregation(agg[:name], agg[:args])
+          end
+        end
+      end
+
+      def build_fields
+        structure.fields do
+          structure.array! fields.flatten
+        end
+      end
+
+      def build_search_options
+        values[:search_option] ||= []
+
+        opts = extra_search_options
+        (values[:search_option] + [opts]).compact.inject(Hash.new) { |h,k,v| h.merge(k) }
+      end
+
+      def extra_search_options
+        [:size].inject(Hash.new) { |h,k| h[k] = self.send(k) unless self.send(k).nil?; h}
+      end
+
+      def compact_where(q, opts = {bool:true})
+        return if q.nil?
+        if opts.delete(:bool)
+          as_must(q)
+        else
+          as_query_string(q.flatten)
+        end
+      end
+
+      def as_must(q)
+        _must = []
+        q.each do |arg|
+          arg.each_pair { |k,v| _must << (v.is_a?(Array) ? {terms: Hash[k,v]} : {term: Hash[k,v]}) } if arg.class == Hash
+          _must << {term: Hash[[arg.split(/:/).collect(&:strip)]]} if arg.class == String
+          _must << arg.first if arg.class == Array
+        end
+        _must.length == 1 ? _must.first : _must
+      end
+
+      def as_query_string(q)
+        _and = []
+
+        @query_string_options = q.pop if q.length > 1
+
+        q.each do |arg|
+          arg.each_pair { |k,v|  _and << "(#{k}:#{v})" } if arg.class == Hash
+          _and << "(#{arg})" if arg.class == String
+        end
+        _and.join(" AND ")
+      end
+
+
+
+      def extract_highlighter(highlighter)
+        Jbuilder.new do |highlight|
+          highlight.extract! highlighter
+        end
+      end
+
+      def extract_filters(name,opts = {})
+        Jbuilder.new do |filter|
+            case
+            when opts.is_a?(Hash)
+                filter.extract! opts, *opts.keys
+            when opts.is_a?(Array)
+                extract_filter_arguments_from_array(filter, opts)
+            else
+              raise "#filter only accepts Hash or Array"
+            end
+        end
+      end
+
+      def aggregation(name, opts = {})
+        Jbuilder.new do |agg|
+          case
+          when opts.is_a?(Hash)
+              agg.extract! opts, *opts.keys
+          when opts.is_a?(Array)
+              extract_filter_arguments_from_array(agg, opts)
+          else
+            raise "#aggregation only accepts Hash or Array"
+          end
+        end
+      end
+
+      def extract_filter_arguments_from_array(element, opts)
+        opts.each do |opt|
+          element.child! do
+          element.extract! opt , *opt.keys
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/elasticsearch/persistence/relation/query_methods.rb

@@ -0,0 +1,362 @@
+require 'active_support/core_ext/array/wrap'
+
+module Elasticsearch
+  module Persistence
+    module QueryMethods
+      extend ActiveSupport::Concern
+
+
+       MULTI_VALUE_METHODS = [:where, :order, :field, :highlight, :source,
+                              :must_not, :should, :query_string,
+                              :aggregation, :search_option,
+                              :filter, :or_filter, :extending, :skip_callbacks]
+      SINGLE_VALUE_METHODS = [:size]
+
+      class WhereChain
+        def initialize(scope)
+          @scope = scope
+        end
+      end
+
+
+      MULTI_VALUE_METHODS.each do |name|
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}_values                   # def select_values
+            @values[:#{name}] || []            #   @values[:select] || []
+          end                                  # end
+                                               #
+          def #{name}_values=(values)          # def select_values=(values)
+            raise ImmutableRelation if @loaded #   raise ImmutableRelation if @loaded
+            @values[:#{name}] = values         #   @values[:select] = values
+          end                                  # end
+        CODE
+      end
+
+      SINGLE_VALUE_METHODS.each do |name|
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}_value                    # def readonly_value
+            @values[:#{name}]                  #   @values[:readonly]
+          end                                  # end
+        CODE
+      end
+
+      SINGLE_VALUE_METHODS.each do |name|
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}_value=(value)            # def readonly_value=(value)
+            raise ImmutableRelation if @loaded #   raise ImmutableRelation if @loaded
+            @values[:#{name}] = value          #   @values[:readonly] = value
+          end                                  # end
+        CODE
+      end
+
+
+
+      def order(*args)
+        check_if_method_has_arguments!(:order, args)
+        spawn.order!(*args)
+      end
+
+      def order!(*args)
+        self.order_values += [preprocess_order_args(args)]
+        self
+      end
+
+      alias :sort :order
+
+
+      def skip_callbacks(*args)
+        spawn.skip_callbacks!(*args)
+      end
+
+      def skip_callbacks!(*args)
+        self.skip_callbacks_values += args
+        self
+      end
+
+      alias :sort :order
+
+
+      def size(args)
+        spawn.size!(args)
+      end
+
+      def size!(args)
+        self.size_value = args
+        self
+      end
+
+      alias :limit :size
+
+
+
+
+      def where(opts = :chain, *rest)
+        if opts == :chain
+          WhereChain.new(spawn)
+        elsif opts.blank?
+          self
+        else
+          spawn.where!(opts, *rest)
+        end
+      end
+
+      alias :must :where
+
+      def where!(opts, *rest) # :nodoc:
+        if opts == :chain
+          WhereChain.new(self)
+        else
+          #if Hash === opts
+            #opts = sanitize_forbidden_attributes(opts)
+          #end
+
+          self.where_values += build_where(opts, rest)
+          self
+        end
+      end
+
+
+
+
+      def query_string(opts = :chain, *rest)
+        if opts == :chain
+          WhereChain.new(spawn)
+        elsif opts.blank?
+          self
+        else
+          spawn.query_string!(opts, *rest)
+        end
+      end
+
+      def query_string!(opts, *rest) # :nodoc:
+        if opts == :chain
+          WhereChain.new(self)
+        else
+          self.query_string_values += build_where(opts, rest)
+          self
+        end
+      end
+
+
+
+
+      def must_not(opts = :chain, *rest)
+        if opts == :chain
+          WhereChain.new(spawn)
+        elsif opts.blank?
+          self
+        else
+          spawn.must_not!(opts, *rest)
+        end
+      end
+
+      alias :where_not :must_not
+
+      def must_not!(opts, *rest)
+        if opts == :chain
+          WhereChain.new(self)
+        else
+          self.must_not_values += build_where(opts, rest)
+          self
+        end
+      end
+
+
+
+
+      def should(opts = :chain, *rest)
+        if opts == :chain
+          WhereChain.new(spawn)
+        elsif opts.blank?
+          self
+        else
+          spawn.should!(opts, *rest)
+        end
+      end
+
+      def should!(opts, *rest)
+        if opts == :chain
+          WhereChain.new(self)
+        else
+          self.should_values += build_where(opts, rest)
+          self
+        end
+      end
+
+
+      def or_filter(name, options = {}, &block)
+        spawn.or_filter!(name, options, &block)
+      end
+
+      def or_filter!(name, options = {}, &block)
+        self.or_filter_values += [{name: name, args: options}]
+        self
+      end
+
+
+
+      def filter(name, options = {}, &block)
+        spawn.filter!(name, options, &block)
+      end
+
+      def filter!(name, options = {}, &block)
+        self.filter_values += [{name: name, args: options}]
+        self
+      end
+
+
+
+
+      def aggregation(name, options = {}, &block)
+        spawn.aggregation!(name, options, &block)
+      end
+
+      def aggregation!(name, options = {}, &block)
+        self.aggregation_values += [{name: name, args: options}]
+        self
+      end
+
+
+
+
+      def field(*args)
+        spawn.field!(*args)
+      end
+      alias :fields :field
+
+      def field!(*args)
+        self.field_values += args
+        self
+      end
+
+
+
+
+      def source(*args)
+        spawn.source!(*args)
+      end
+
+      def source!(*args)
+        self.source_values += args
+        self
+      end
+
+
+
+
+      def has_field?(field)
+        spawn.filter(:exists, {field: field})
+      end
+
+
+
+
+      def bind(value)
+        spawn.bind!(value)
+      end
+
+      def bind!(value) # :nodoc:
+        self.bind_values += [value]
+        self
+      end
+
+      def build_where(opts, other = [])
+        case opts
+        when String, Array
+          #TODO: Remove duplication with: /activerecord/lib/active_record/sanitization.rb:113
+          values = Hash === other.first ? other.first.values : other
+
+          values.grep(Elasticsearch::Persistence::Relation) do |rel|
+            self.bind_values += rel.bind_values
+          end
+
+          [other.empty? ? opts : ([opts] + other)]
+        when Hash
+          [other.empty? ? opts : ([opts] + other)]
+        else
+          [opts]
+        end
+      end
+
+      def highlight(*args)
+        spawn.highlight!(*args)
+      end
+
+      def highlight!(*args)
+        self.highlight_values += args
+        self
+      end
+
+
+      # Returns a chainable relation with zero records.
+      #
+      #
+      def none
+        extending(NullRelation)
+      end
+
+      def none! # :nodoc:
+        extending!(NullRelation)
+      end
+
+
+      def extending(*modules, &block)
+        if modules.any? || block
+          spawn.extending!(*modules, &block)
+        else
+          self
+        end
+      end
+
+      def extending!(*modules, &block) # :nodoc:
+        modules << Module.new(&block) if block
+        modules.flatten!
+
+        self.extending_values += modules
+        extend(*extending_values) if extending_values.any?
+
+        self
+      end
+
+      private
+
+      def check_if_method_has_arguments!(method_name, args)
+        if args.blank?
+          raise ArgumentError, "The method .#{method_name}() must contain arguments."
+        end
+      end
+
+      VALID_DIRECTIONS = [:asc, :desc, :ASC, :DESC,
+                          'asc', 'desc', 'ASC', 'DESC'] # :nodoc:
+
+      def validate_order_args(args)
+        args.each do |arg|
+          next unless arg.is_a?(Hash)
+          arg.each do |_key, value|
+            raise ArgumentError, "Direction \"#{value}\" is invalid. Valid " \
+                                 "directions are: #{VALID_DIRECTIONS.inspect}" unless VALID_DIRECTIONS.include?(value)
+          end
+        end
+      end
+
+      def preprocess_order_args(order_args)
+        args = order_args.reject{ |arg| arg.is_a?(Hash) }.take(2)
+        return [Hash[[args]]] if args.length == 2
+        order_args.select { |arg| arg.is_a?(Hash)}.flatten
+      end
+
+      def add_relations_to_bind_values(attributes)
+        if attributes.is_a?(Hash)
+          attributes.each_value do |value|
+            if value.is_a?(ActiveRecord::Relation)
+              self.bind_values += value.bind_values
+            else
+              add_relations_to_bind_values(value)
+            end
+          end
+        end
+      end
+    end
+
+    end
+end

data/lib/elasticsearch/persistence/relation/search_option_methods.rb

@@ -0,0 +1,44 @@
+module Elasticsearch
+  module Persistence
+
+    module SearchOptionMethods
+      extend ActiveSupport::Concern
+
+      def routing(args)
+        check_if_method_has_arguments!(:routing, args)
+        spawn.routing!(args)
+      end
+
+      def routing!(args)
+        merge_search_option_values(:routing, args)
+        self
+      end
+
+      def search_type(args)
+        check_if_method_has_arguments!(:search_type, args)
+        spawn.search_type!(args)
+      end
+
+      def search_type!(args)
+        merge_search_option_values(:search_type, args)
+        self
+      end
+
+      def search_options(*args)
+        spawn.search_options!(*args)
+      end
+
+      def search_options!(*args)
+        self.search_option_values += args
+        self
+      end
+
+      private
+
+      def merge_search_option_values(key, value)
+        self.search_option_values += [Hash[key,value]]
+      end
+
+    end
+  end
+end