stretchy-model 0.1.0

data/lib/stretchy/relations/finder_methods.rb

@@ -0,0 +1,39 @@
+module Stretchy
+  module Relations
+
+      module FinderMethods
+
+        def first
+          return results.first if @loaded
+          spawn.first!.results.first
+        end
+
+        def first!
+          spawn.sort(Hash[default_sort_key, :asc]).spawn.size(1)
+          self
+        end
+
+        def last
+          return results.last if @loaded
+          spawn.last!.results.first
+        end
+
+        def last!
+          spawn.sort(Hash[default_sort_key, :desc]).spawn.size(1)
+          self
+        end
+
+        def count
+          return results.count if @loaded
+          spawn.count!
+        end
+
+        def count!
+          @values[:count] = true
+          @values.delete(:size)
+          spawn.results
+        end
+
+      end
+    end
+end

data/lib/stretchy/relations/merger.rb

@@ -0,0 +1,179 @@
+require 'active_support/core_ext/hash/keys'
+require "set"
+
+module Stretchy
+  module Relations
+    class Relation
+      class HashMerger # :nodoc:
+        attr_reader :relation, :hash
+
+        def initialize(relation, hash)
+          hash.assert_valid_keys(*Relation::VALUE_METHODS)
+
+          @relation = relation
+          @hash     = hash
+        end
+
+        def merge
+          Merger.new(relation, other).merge
+        end
+
+        # Applying values to a relation has some side effects. E.g.
+        # interpolation might take place for where values. So we should
+        # build a relation to merge in rather than directly merging
+        # the values.
+        def other
+          other = Relation.create(relation.klass)
+          hash.each { |k, v|
+            if k == :joins
+              if Hash === v
+                other.joins!(v)
+              else
+                other.joins!(*v)
+              end
+            elsif k == :select
+              other._select!(v)
+            else
+              other.send("#{k}!", v)
+            end
+          }
+          other
+        end
+      end
+
+      class Merger # :nodoc:
+        attr_reader :relation, :values, :other
+
+        def initialize(relation, other)
+          @relation = relation
+          @values   = other.values
+          @other    = other
+        end
+
+        NORMAL_VALUES = [:where, :first, :last, :filter]
+
+        def normal_values
+          NORMAL_VALUES
+        end
+
+        def merge
+          normal_values.each do |name|
+            value = values[name]
+            # The unless clause is here mostly for performance reasons (since the `send` call might be moderately
+            # expensive), most of the time the value is going to be `nil` or `.blank?`, the only catch is that
+            # `false.blank?` returns `true`, so there needs to be an extra check so that explicit `false` values
+            # don't fall through the cracks.
+
+            unless value.nil? || (value.blank? && false != value)
+              if name == :select
+                relation._select!(*value)
+              elsif name == :filter
+                values.each do |v|
+                  relation.send("#{name}!", v.first, v.last)
+                end
+              else
+                relation.send("#{name}!", *value)
+              end
+            end
+          end
+
+          merge_multi_values
+          merge_single_values
+          #merge_joins
+
+          relation
+        end
+
+        private
+
+        def merge_joins
+          return if values[:joins].blank?
+
+          if other.klass == relation.klass
+            relation.joins!(*values[:joins])
+          else
+            joins_dependency, rest = values[:joins].partition do |join|
+              case join
+              when Hash, Symbol, Array
+                true
+              else
+                false
+              end
+            end
+
+            join_dependency = ActiveRecord::Associations::JoinDependency.new(other.klass,
+                                                                             joins_dependency,
+                                                                             [])
+            relation.joins! rest
+
+            @relation = relation.joins join_dependency
+          end
+        end
+
+        def merge_multi_values
+          lhs_wheres = relation.where_values
+          rhs_wheres = values[:where] || []
+
+          lhs_filters = relation.filter_values
+          rhs_filters = values[:filter] || []
+
+          removed, kept = partition_overwrites(lhs_wheres, rhs_wheres)
+
+          where_values = kept + rhs_wheres
+
+          filters_removed, filters_kept = partition_overwrites(lhs_wheres, rhs_wheres)
+          filter_values =  rhs_filters
+
+
+          relation.where_values = where_values.empty? ? nil : where_values
+          relation.filter_values = filter_values.empty? ? nil : filter_values
+
+          if values[:reordering]
+            # override any order specified in the original relation
+            relation.reorder! values[:order]
+          elsif values[:order]
+            # merge in order_values from relation
+            relation.order! values[:order]
+          end
+
+          relation.extend(*values[:extending]) unless values[:extending].blank?
+        end
+
+        def merge_single_values
+          #relation.from_value          = values[:from] unless relation.from_value
+          #relation.lock_value          = values[:lock] unless relation.lock_value
+
+          unless values[:create_with].blank?
+            relation.create_with_value = (relation.create_with_value || {}).merge(values[:create_with])
+          end
+        end
+
+        def filter_binds(lhs_binds, removed_wheres)
+          return lhs_binds if removed_wheres.empty?
+
+          set = Set.new removed_wheres.map { |x| x.left.name.to_s }
+          lhs_binds.dup.delete_if { |col,_| set.include? col.name }
+        end
+
+        # Remove equalities from the existing relation with a LHS which is
+        # present in the relation being merged in.
+        # returns [things_to_remove, things_to_keep]
+        def partition_overwrites(lhs_wheres, rhs_wheres)
+          if lhs_wheres.empty? || rhs_wheres.empty?
+            return [[], lhs_wheres]
+          end
+
+          nodes = rhs_wheres.find_all do |w|
+            w.respond_to?(:operator) && w.operator == :==
+          end
+          seen = Set.new(nodes) { |node| node.left }
+
+          lhs_wheres.partition do |w|
+            w.respond_to?(:operator) && w.operator == :== && seen.include?(w.left)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/stretchy/relations/query_builder.rb

@@ -0,0 +1,265 @@
+module Stretchy
+  module Relations
+    class QueryBuilder
+
+      attr_reader :structure, :values
+
+      def initialize(values)
+        @structure = Jbuilder.new ignore_nil: true
+        @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!.with_indifferent_access
+      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.set! :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.with_indifferent_access
+      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?
+
+          query_filters.each do |f|
+            structure.child! do
+              structure.set! f[:name], extract_filters(f[:name], f[:args])
+            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.includes source.first.delete(:includes) if source.first.has_key? :includes
+              structure.excludes source.first.delete(:excludes) if source.first.has_key? :excludes
+          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_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