ansr 0.0.1 → 0.0.3

data/lib/ansr/model.rb

@@ -1,8 +1,9 @@
 module Ansr
   module Model
-  	module Methods
+    extend ActiveSupport::Concern
+  	module ClassMethods
       def spawn
-        s = Ansr::Relation.new(model(), table())
+        s = build_default_scope
         s.references!(references())
       end
 
@@ -27,11 +28,12 @@ module Ansr
       end
 
       def table
-        raise 'Implementing classes must provide a BigTable reader'
-      end
-
-      def table=(table)
-        raise 'Implementing classes must provide a BigTable writer'
+        type = (config[:table_class] || Ansr::Arel::BigTable)
+        if @table
+          # allow the table class to be reconfigured
+          @table = nil unless @table.class == type
+        end
+        @table ||= type.new(self)
       end
 
       def engine
@@ -46,114 +48,22 @@ module Ansr
         Ansr::Relation.new(model(), table())
 	    end
 
-      def view(*wheres)
-        return ViewProxy.new(model(), *wheres)
+      def column_types
+        TypeProxy.new(table())
       end
-    end
 
-    class ViewProxy
-      attr_accessor :model
-      def initialize(model, *wheres)
-        if ViewProxy === model
-          @model = model.model
-          self.constraints = Array(model.constraints)
-          self.projections = model.projections.dup
-        else
-          @model = model
-        end
-        if wheres[0]
-          self.constraints = self.constraints + wheres
+      class TypeProxy
+        def initialize(table)
+          @table = table
         end
-      end
 
-      def view_arel(engine, table)
-        arel = ::Arel::SelectManager.new(engine, table)
-        constraints.each {|c| arel.where(c) }
-        arel.project projections()
-        arel
-      end
-
-      def find_by_nosql(arel, bind_values)
-        filter_context = nil
-        if self.view?
-          filter_context = view_arel(arel.engine, arel.source.left)
-          arel = arel.intersect filter_context
+        def [](name)
+          # this should delegate to the NoSqlAdapter
+          ::ActiveRecord::ConnectionAdapters::Column.new(name.to_s, nil, String)
         end
-        model.find_by_nosql(arel, bind_values)
-      end
-
-      def expand_hash_conditions_for_aggregates(attrs)
-        # this is a protected method in the AR sanitization module
-        model.send(:expand_hash_conditions_for_aggregates, attrs)
-      end
-
-      def constraints
-        @constraints ||= []
-      end
-
-      def constraints=(values)
-        @constraints = Array === (values) ? values : Array(values)
-      end
-
-      def projections
-        @projections ||= []
-      end
-
-      def projections=(values)
-        @projections = Array === (values) ? values : Array(values)
-      end
-
-      def view?
-        (@constraints and @constraints.length > 0) or (@projections and @projections.length > 0)
-      end
-
-      def view(*wheres)
-        ViewProxy.new(self, wheres)
-      end
-
-      def self.===(other)
-        other.is_a? ViewProxy
-      end
-
-      def connection_handler=(handler)
-        @connection_handler = handler
-      end
-
-      def build_default_scope
-        model().all
-      end
-
-      # model delegations
-      def connection
-        model().connection
-      end
-
-      def name
-        model().name
-      end
-
-      def table
-        model().table
-      end
-
-      def arel_table
-        model().arel_table
-      end
-
-      def current_scope=(scope)
-        model().current_scope=(scope)
-      end
-
-      def current_scope
-        model().current_scope
-      end
-
-      def method_missing(method, *args, &block)
-        model().send(method, *args, &block)
       end
     end
 
-    require 'ansr/model/connection'
     require 'ansr/model/connection_handler'
   end
 end

data/lib/ansr/model/connection_handler.rb

@@ -4,6 +4,12 @@ module Ansr
       def initialize(connection_class)
         @connection_class = connection_class
       end
+
+      def adapter
+        @connection_class
+      end
+
+      # retrieve a datasource adapter
       def retrieve_connection(klass)
         @connection_class.new(klass)
       end

data/lib/ansr/relation.rb

@@ -2,12 +2,15 @@ require 'yaml'
 require 'blacklight'
 module Ansr
   class Relation < ::ActiveRecord::Relation
+    attr_reader :response
     attr_accessor :filters, :count, :context, :resource
 
     DEFAULT_PAGE_SIZE = 10
     
     include Sanitization::ClassMethods
     include QueryMethods
+    include Kaminari::PageScopeMethods
+    alias :total_count :count
 
     def initialize(klass, table, values = {})
       raise "Cannot search nil model" if klass.nil?
@@ -20,6 +23,10 @@ module Ansr
       rsrc.to_sym
     end
 
+    def default_limit_value
+      DEFAULT_PAGE_SIZE
+    end
+
     def load
       exec_queries unless loaded?
       self
@@ -46,35 +53,36 @@ module Ansr
     end
 
     def offset!(value)
-      page_size = self.limit_value || DEFAULT_PAGE_SIZE
-      if (value.to_i % page_size.to_i) != 0
-        raise "Bad offset #{value} for page size #{page_size}"
-      end
       self.offset_value=value
       self
     end
 
-    def count
+    def count()
       self.load
-      @response['count']
+      @response.count
+    end
+
+    def total_count
+      count
+    end
+
+    def max_pages
+      (total_count.to_f / limit_value).ceil
+    end
+
+    # override to parse filters from response 
+    def filters_from(response)
+      {} and raise "this is a dead method!"
+    end
+
+    # override to parse docs from response
+    def docs_from(response)
+      []
     end
 
     def filters
       if loaded?
-        @filter_cache ||= begin
-          f = {}
-          (@response['facets'] || {}).inject(f) do |h,(k,v)|
-            if v['total'] = 0
-              items = v['terms'].collect do |term|
-                Blacklight::SolrResponse::Facets::FacetItem.new(:value => term['term'], :hits => term['count'])
-              end
-              options = {:sort => 'asc', :offset => 0}
-              h[k] = Blacklight::SolrResponse::Facets::FacetField.new k, items, options
-            end
-            h
-          end
-          f
-        end
+        @filter_cache = filters_from(response)
       else
         @filter_cache ||= begin 
           query = self.limit(0)
@@ -92,13 +100,23 @@ module Ansr
 
     private
 
+    # override to prevent default selection of all fields
+    def build_select(arel, selects)
+      unless selects.empty?
+        @implicit_readonly = false
+        arel.project(*selects)
+      #else
+      #  arel.project(@klass.arel_table[Arel.star])
+      end
+    end
+
 
     def exec_queries
       default_scoped = with_default_scope
 
       if default_scoped.equal?(self)
         @response = model.find_by_nosql(arel, bind_values)
-        @records = (@response['docs'] || []).collect do |d|
+        @records = docs_from(@response).collect do |d|
           model.new(d)
         end
 
@@ -109,7 +127,7 @@ module Ansr
         @records = default_scoped.to_a
       end
 
-      self.limit_value = DEFAULT_PAGE_SIZE unless self.limit_value
+      self.limit_value = default_limit_value unless self.limit_value
       self.offset_value = 0 unless self.offset_value
       @filter_cache = nil # unload any cached filters
       @loaded = true
@@ -117,5 +135,4 @@ module Ansr
     end
   end
 
-
 end

data/lib/ansr/relation/group.rb

@@ -0,0 +1,31 @@
+# encapsulate a set of a response documents grouped on a field
+module Ansr
+  class Group
+    attr_reader :field, :key, :group, :model
+    def initialize(group_key, model, group)
+      @field, @key = group_key.first
+      @model = model
+      @group = group
+    end
+
+    # size of the group
+    def total
+      raise "Group#total must be implemented by subclass"
+    end
+
+    # offset in the response
+    def start
+      raise "Group#start must be implemented by subclass"
+    end
+
+    # model instances belonging to this group
+    def records
+      raise "Group#records must be implemented by subclass"
+    end
+
+    # the field from which the key value was selected
+    def field
+      raise "Group#field must be implemented by subclass"
+    end
+  end
+end

data/lib/ansr/relation/predicate_builder.rb

@@ -0,0 +1,106 @@
+module Ansr
+  class PredicateBuilder # :nodoc:
+    def self.build_from_hash(klass, attributes, default_table)
+      queries = []
+
+      attributes.each do |column, value|
+        table = default_table
+
+        if value.is_a?(Hash)
+          if value.empty?
+            queries << '1=0'
+          else
+            table       = default_table.class.new(column, default_table.engine)
+            association = klass.reflect_on_association(column.to_sym)
+
+            value.each do |k, v|
+              queries.concat expand(association && association.klass, table, k, v)
+            end
+          end
+        else
+          column = column.to_s
+        # we remove the below since big table fields don't really have associations
+        #  if column.include?('.')
+        #    table_name, column = column.split('.', 2)
+        #    table = Ansr::Arel::BigTable.new(table_name, default_table.engine)
+        #  end
+
+          queries.concat expand(klass, table, column, value)
+        end
+      end
+
+      queries
+    end
+
+    def self.expand(klass, table, column, value)
+      queries = []
+
+      # Find the foreign key when using queries such as:
+      # Post.where(author: author)
+      #
+      # For polymorphic relationships, find the foreign key and type:
+      # PriceEstimate.where(estimate_of: treasure)
+      if klass && value.class < Base && reflection = klass.reflect_on_association(column.to_sym)
+        if reflection.polymorphic?
+          queries << build(table[reflection.foreign_type], value.class.base_class)
+        end
+
+        column = reflection.foreign_key
+      end
+
+      queries << build(table[column], value)
+      queries
+    end
+
+    def self.references(attributes)
+      attributes.map do |key, value|
+        if value.is_a?(Hash)
+          key
+        else
+          key = key.to_s
+          key.split('.').first if key.include?('.')
+        end
+      end.compact
+    end
+
+    private
+      def self.build(attribute, value)
+        case value
+        when Array
+          values = value.to_a.map {|x| x.is_a?(Base) ? x.id : x}
+          ranges, values = values.partition {|v| v.is_a?(Range)}
+
+          values_predicate = if values.include?(nil)
+            values = values.compact
+
+            case values.length
+            when 0
+              attribute.eq(nil)
+            when 1
+              attribute.eq(values.first).or(attribute.eq(nil))
+            else
+              attribute.in(values).or(attribute.eq(nil))
+            end
+          else
+            attribute.in(values)
+          end
+
+          array_predicates = ranges.map { |range| attribute.in(range) }
+          array_predicates << values_predicate
+          array_predicates.inject { |composite, predicate| composite.or(predicate) }
+        when ActiveRecord::Relation
+          value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
+          attribute.in(value.arel.ast)
+        when Range
+          attribute.in(value)
+        when ActiveRecord::Base
+          attribute.eq(value.id)
+        when Class
+          # FIXME: I think we need to deprecate this behavior
+          attribute.eq(value.name)
+        else
+          attribute.eq(value)
+        end
+      end
+  end
+end

data/lib/ansr/relation/query_methods.rb

@@ -9,9 +9,8 @@ module Ansr
         where_value = @scope.send(:build_where, opts, rest).map do |rel|
           case rel
           when ::Arel::Nodes::In
-            next rel
+            ::Arel::Nodes::Or.new(rel.left, rel.right)
           when ::Arel::Nodes::Equality
-            # ::Arel::Nodes::OrEqual.new(rel.left, rel.right)
             ::Arel::Nodes::Or.new(rel.left, rel.right)
           when String
             ::Arel::Nodes::Or.new(::Arel::Nodes::SqlLiteral.new(rel))
@@ -34,52 +33,164 @@ module Ansr
       @values[:filter] = values
     end
 
-    def filter(args)
-      check_if_method_has_arguments!("filter", args)
-      spawn.filter!(args)
+    def filter(expr)
+      check_if_method_has_arguments!("filter", expr)
+      spawn.filter!(expr)
     end
 
-    def filter!(args)
-      return self if args.empty?
+    def filter!(expr)
+      return self if expr.empty?
 
-      filter_where = build_filter(args)
-      return self unless filter_where
-      filter_name = filter_name(filter_where)
-      if (filter_name)
-        @klass = @klass.view(*filter_where)
-        model().projections += Array(filter_name)
+      filter_nodes = build_where(expr)
+      return self unless filter_nodes
+      filters = []
+      filter_nodes.each do |filter_node|
+        case filter_node
+        when ::Arel::Nodes::In, ::Arel::Nodes::Equality
+          filter_node.left = Ansr::Arel::Nodes::Filter.new(filter_node.left)
+        when ::Arel::SqlLiteral
+          filter_node = Ansr::Arel::Nodes::Filter.new(filter_node)
+        when String, Symbol
+          filter_node = Ansr::Arel::Nodes::Filter.new(::Arel::SqlLiteral.new(filter_node.to_s))
+        else
+          raise "unexpected filter node type #{filter_node.class}"
+        end
+        filters << filter_node
       end
+      self.filter_values+= filters 
     
       self
     end
 
+    def filter_unscoping(target_value)
+      target_value_sym = target_value.to_sym
+
+      filter_values.reject! do |rel|
+        case rel
+        when ::Arel::Nodes::In, ::Arel::Nodes::Equality
+          subrelation = (rel.left.kind_of?(::Arel::Attributes::Attribute) ? rel.left : rel.right)
+          subrelation.name.to_sym == target_value_sym
+        else
+          raise "unscope(filter: #{target_value.inspect}) failed: unscoping #{rel.class} is unimplemented."
+        end
+      end
+    end
+
+    def facet(expr, opts = {})
+      spawn.facet!(expr, opts)
+    end
+
+    def facet!(expr, opts={})
+      self.facet_values+= build_facets(expr, opts)
+      self
+    end
+
+    def facet_values
+      @values[:facets] || []
+    end
+
+    def facet_values=(values)
+      raise ActiveRecord::ImmutableRelation if @loaded
+      @values[:facets]=values
+    end
+
+    def facet_unscoping(target_value)
+    end
+
     def filter_name(expr)
       connection.sanitize_filter_name(field_name(expr))
     end
 
+    def as(args)
+      spawn.as!(args)
+    end
+
+    def as!(args)
+      self.as_value= args
+      self
+    end
+
+    def as_value
+      @values[:as]
+    end
+
+    def as_value=(args)
+      raise ActiveRecord::ImmutableRelation if @loaded
+      @values[:as] = args
+    end
+
+    def as_unscoping(*args)
+      @values.delete(:as)
+    end
+
+    def highlight(expr, opts={})
+      spawn.highlight!(expr, opts)
+    end
+
+    def highlight!(expr, opts = {})
+      self.highlight_value= Ansr::Arel::Nodes::Highlight.new(expr, opts)
+    end
+
+    def highlight_value
+      @values[:highlight]
+    end
+
+    def highlight_value=(val)
+      raise ActiveRecord::ImmutableRelation if @loaded
+      @values[:highlight] = val
+    end
+
+    def highlight_unscoping(*args)
+      @values.delete(:highlight)
+    end
+
+    def spellcheck(expr, opts={})
+      spawn.spellcheck!(expr, opts)
+    end
+
+    def spellcheck!(expr, opts = {})
+      self.spellcheck_value= Ansr::Arel::Nodes::Spellcheck.new(expr, opts)
+    end
+
+    def spellcheck_value
+      @values[:spellcheck]
+    end
+
+    def spellcheck_value=(val)
+      raise ActiveRecord::ImmutableRelation if @loaded
+      @values[:spellcheck] = val
+    end
+
+    def spellcheck_unscoping(*args)
+      @values.delete(:spellcheck)
+    end
+
     def field_name(expr)
       if expr.is_a? Array
         return expr.collect{|x| field_name(x)}.compact
       else
         case expr
         when ::Arel::Nodes::Binary
-          if expr.left.relation.name != model().name
+          if expr.left.relation.name != model().table.name
             # oof, this is really hacky
             field_name = "#{expr.left.relation.name}.#{expr.left.name}".to_sym
+            field_name = expr.left.name.to_sym
           else
             field_name = expr.left.name.to_sym
           end
-        when ::Arel::Attributes::Attribute
-          if expr.relation.name != model().name
+        when ::Arel::Attributes::Attribute, Ansr::Arel::ConfiguredField
+          if expr.relation.name != model().table.name
             # oof, this is really hacky
             field_name = "#{expr.relation.name}.#{expr.name}".to_sym
+            field_name = expr.name.to_sym
           else
             field_name = expr.name.to_sym
           end
-        when ::Arel::Nodes::Unary
-          if expr.expr.relation.name != model().name
+        when ::Arel::Nodes::Unary, Ansr::Arel::Nodes::Filter
+          if expr.expr.relation.name != model().table.name
             # oof, this is really hacky
             field_name = "#{expr.expr.relation.name}.#{expr.expr.name}".to_sym
+            field_name = expr.expr.name.to_sym
           else
             field_name = expr.expr.name.to_sym
           end
@@ -100,7 +211,7 @@ module Ansr
 
     def find(id)
       klass = model()
-      rel = klass.build_default_scope.where(klass.table.primary_key.name => id).limit(1)
+      rel = where(klass.table.primary_key.name => id).limit(1)
       rel.to_a
       unless rel.to_a[0]
         raise 'Bad ID'
@@ -111,46 +222,82 @@ module Ansr
     def collapse_wheres(arel, wheres)
       predicates = wheres.map do |where|
         next where if ::Arel::Nodes::Equality === where
-        where if String === where
+        where = Arel.sql(where) if String === where # SqlLiteral-ize
         ::Arel::Nodes::Grouping.new(where)
       end
 
       arel.where(::Arel::Nodes::And.new(predicates)) if predicates.present?
     end
 
+    def collapse_filters(arel, filters)
+      predicates = filters.map do |filter|
+        next filter if ::Arel::Nodes::Equality === filter
+        filter = Arel.sql(filter) if String === filter # SqlLiteral-ize
+        ::Arel::Nodes::Grouping.new(filter)
+      end
+
+      arel.where(::Arel::Nodes::And.new(predicates)) if predicates.present?
+    end
+
+    # Could filtering be moved out of intersection into one arel tree?
+    def build_arel
+      arel = super
+      collapse_filters(arel, (filter_values).uniq)
+      arel.projections << @values[:spellcheck] if @values[:spellcheck]
+      arel.projections << @values[:highlight] if @values[:highlight]
+      arel.projections += facet_values
+      arel.from arel.create_table_alias(arel.source.left, as_value) if as_value
+      arel
+    end      
+
     # cloning from ActiveRecord::QueryMethods.build_where as a first pass
-    def build_filter(opts, other=[])
+    def build_facets(expr, opts={})
+      case expr
+      when Hash
+        build_facets(::Arel.star,expr)
+      when Array
+        r = expr.inject([]) {|m,e| m.concat build_facets(e,opts)}
+      when String, Symbol, Arel::SqlLiteral
+        [Ansr::Arel::Nodes::Facet.new(::Arel::Attributes::Attribute.new(table, expr.to_s), opts)]
+      when ::Arel::Attributes::Attribute
+        [Ansr::Arel::Nodes::Facet.new(expr, opts)]
+      else
+        [expr]
+      end
+    end
+
+    # cloning from ActiveRecord::QueryMethods.build_where to use our PredicateBuilder
+    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
+      when String, Array
+        #TODO: Remove duplication with: /activerecord/lib/active_record/sanitization.rb:113
+        values = Hash === other.first ? other.first.values : other
 
-          values.grep(ActiveRecord::Relation) do |rel|
-            self.bind_values += rel.bind_values
-          end
-          opts = (other.empty? ? opts : ([opts] + other))
-          [model().send(:sanitize_sql, opts, model().table_name)]
-        when Hash
-          attributes = model().send(:expand_hash_conditions_for_sql_aggregates, opts)
-
-          attributes.keys.each do |k|
-            sk = filter_name(k)
-            attributes[sk] = attributes.delete(k) unless sk.eql? k.to_s
-          end
-          attributes.values.grep(ActiveRecord::Relation) do |rel|
-            self.bind_values += rel.bind_values
-          end
+        values.grep(ActiveRecord::Relation) do |rel|
+          self.bind_values += rel.bind_values
+        end
 
-          ActiveRecord::PredicateBuilder.build_from_hash(model(), attributes, model().table)
-        else
-          [opts]
+        [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
+      when Hash
+        attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)
+
+        attributes.values.grep(ActiveRecord::Relation) do |rel|
+          self.bind_values += rel.bind_values
+        end
+
+        PredicateBuilder.build_from_hash(klass, attributes, table)
+      else
+        [opts]
       end
     end
 
     def find_by_nosql(arel, bind_values)
-      query = model.connection.to_nosql(arel, bind_values)
-      aliases = model.connection.to_aliases(arel, bind_values)
-      model.connection.execute(query, aliases)
+      @ansr_query = model.connection.to_nosql(arel, bind_values)
+      model.connection.execute(@ansr_query)
+    end
+
+    def ansr_qeury
+      @ansr_query
     end
   end
 end