model_set 1.0.0 → 1.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+/pkg/
+*~

data/.rbenv-gemsets

@@ -0,0 +1 @@
+model_set

data/.rbenv-version

@@ -0,0 +1 @@
+ree-1.8.7-2012.02

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://www.rubygems.org"
+
+gemspec

data/Rakefile

@@ -1,47 +1,10 @@
-require 'rake'
 require 'rake/testtask'
-require 'rake/rdoctask'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name = "model_set"
-    s.summary = %Q{Easy manipulation of sets of ActiveRecord models}
-    s.email = "code@justinbalthrop.com"
-    s.homepage = "http://github.com/ninjudd/model_set"
-    s.description = "Easy manipulation of sets of ActiveRecord models"
-    s.authors = ["Justin Balthrop"]
-    s.add_dependency('ordered_set',   '>= 1.0.1')
-    s.add_dependency('deep_clonable', '>= 1.1.0')
-    s.add_dependency('activerecord', '>= 2.0.0')
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
+require 'bundler/gem_tasks'
 
 Rake::TestTask.new do |t|
-  t.libs << 'lib'
+  t.libs = ['lib']
   t.pattern = 'test/**/*_test.rb'
   t.verbose = false
 end
 
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'model_set'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |t|
-    t.libs << 'test'
-    t.test_files = FileList['test/**/*_test.rb']
-    t.verbose = true
-  end
-rescue LoadError
-end
-
 task :default => :test

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.1.0

data/lib/model_set/conditioned.rb

@@ -2,28 +2,27 @@ class ModelSet
   module Conditioned
     # Shared methods for dealing with conditions.
     attr_accessor :conditions
-    
-    def add_conditions!(*conditions)
-      operator = conditions.shift if conditions.first.kind_of?(Symbol)
-      operator ||= :and
 
-      # Sanitize conditions.
-      conditions.collect! do |condition|
-        condition.kind_of?(Conditions) ? condition : Conditions.new( sanitize_condition(condition) )
-      end
+    def add_conditions!(*conditions)
+      new_conditions = conditions.first.kind_of?(Symbol) ? [conditions.shift] : []
 
-      if operator == :not
-        # In this case, :not actually means :and :not.
-        conditions = ~Conditions.new(:and, *conditions)
-        operator   = :and
+      conditions.each do |condition|
+        if condition.kind_of?(Conditions)
+          new_conditions << condition
+        else
+          new_conditions.concat([*transform_condition(condition)])
+        end
       end
+      return self if new_conditions.empty?
 
-      conditions << @conditions if @conditions
-      @conditions = Conditions.new(operator, *conditions)
-
+      @conditions = to_conditions(*new_conditions) << @conditions
       clear_cache!
     end
 
+    def to_conditions(*conditions)
+      Conditions.new(conditions, condition_ops)
+    end
+
     def invert!
       raise 'cannot invert without conditions' if @conditions.nil?
       @conditions = ~@conditions

data/lib/model_set/conditions.rb

@@ -4,40 +4,27 @@ class ModelSet
 
     attr_reader :operator, :conditions
 
-    def self.new(*args)
-      if args.size == 1 and args.first.kind_of?(self)
-        # Just clone if the only argument is a Conditions object.
-        args.first.clone
-      elsif args.size == 2 and [:and, :or].include?(args.first)
-        # The operator is not necessary if there is only one subcondition.
-        new(args.last)
-      else
-        super
-      end
-    end
-
     def new(*args)
       self.class.new(*args)
     end
 
-    def initialize(*args)
-      if args.size == 1 and not args.first.kind_of?(Symbol)
-        # Terminal.
-        @conditions = args
-      else
-        @operator = args.shift
-        raise "invalid operator :#{operator}" unless [:and, :or, :not].include?(operator)
-
-        if operator == :not
-          raise "unary operator :not cannot have multiple conditions" if args.size > 1
-          @conditions = [self.class.new(args.first)] 
+    def initialize(conditions, ops)
+      @ops = ops
+      if conditions.kind_of?(Array)
+        @operator = conditions.first.kind_of?(Symbol) ? conditions.shift : :and
+        if @operator == :not
+          # In this case, :not actually means :and :not.
+          @conditions = ~Conditions.new([:and, conditions], @ops)
         else
+          raise "invalid operator :#{operator}" unless [:and, :or].include?(@operator)
           # Compact the conditions if possible.
           @conditions = []
-          args.each do |clause|
+          conditions.each do |clause|
             self << clause
           end
         end
+      else
+        @conditions = [conditions]
       end
     end
 
@@ -46,15 +33,17 @@ class ModelSet
     end
 
     def <<(clause)
+      return self unless clause
       raise 'cannot append conditions to a terminal' if terminal?
-      
-      clause = self.class.new(clause) 
+
+      clause = new(clause, @ops) unless clause.kind_of?(Conditions)
       if clause.operator == operator
         @conditions.concat(clause.conditions)
       else
         @conditions << clause
       end
       @conditions.uniq!
+      self
     end
 
     def ~
@@ -73,20 +62,24 @@ class ModelSet
       new(:and, self, other)
     end
 
+    def op(type)
+      @ops[type]
+    end
+
     def to_s
-      return conditions.first if terminal?
+      return conditions.first.to_s if terminal? or conditions.empty?
 
       condition_strings = conditions.collect do |condition|
         condition.operator == :not ? condition.to_s : "(#{condition.to_s})"
       end.sort_by {|s| s.size}
 
       case operator
-      when :not
-        "NOT #{condition_strings.first}"
-      when :and
-        "#{condition_strings.join(' AND ')}"
-      when :or
-        "#{condition_strings.join(' OR ')}"
+      when :not then
+        "#{op(:not)} #{condition_strings.first}"
+      when :and then
+        "#{condition_strings.join(op(:and))}"
+      when :or then
+        "#{condition_strings.join(op(:or))}"
       end
     end
 

data/lib/model_set/query.rb

@@ -37,27 +37,28 @@ class ModelSet
       @page   = nil if offset
       clear_limited_cache!
     end
-    
+
     def unlimited!
       @limit  = nil
       @offset = nil
       @page   = nil
       clear_limited_cache!
     end
-    
+
     def clear_limited_cache!
       @ids  = nil
       @size = nil
       self
     end
-     
+
     def clear_cache!
       @count = nil
       clear_limited_cache!
     end
 
-    attr_reader :set_class
-    delegate :id_field, :to => :set_class
+    attr_reader :set_class, :limit, :sort_order
+    delegate :id_field,             :to => :set_class
+    delegate :id_field_with_prefix, :to => :set_class
 
     def model_class
       set_class.query_model_class
@@ -71,12 +72,6 @@ class ModelSet
       model_class.table_name
     end
 
-    def id_field_with_prefix
-      "#{table_name}.#{id_field}"
-    end
-
-    attr_reader :limit, :sort_order
-
     def offset
       if limit
         @offset ||= @page ? (@page - 1) * limit : 0
@@ -97,7 +92,7 @@ class ModelSet
       proc = self.class.before_query
       proc.bind(self).call(*args) if proc
     end
-    
+
     def self.before_query(&block)
       if block
         @before_query = block
@@ -132,5 +127,14 @@ class ModelSet
       end
     end
 
+    def condition_ops
+      { :not => 'NOT ',
+        :and => ' AND ',
+        :or  => ' OR ' }
+    end
+
+    def transform_condition(condition)
+      [condition]
+    end
   end
 end

data/lib/model_set/solr_query.rb

@@ -1,15 +1,20 @@
-require 'solr'
+require 'rsolr'
+require 'json'
 
 class ModelSet
   class SolrQuery < Query
-    attr_reader :response
     include Conditioned
 
     MAX_SOLR_RESULTS = 1000
 
+    class << self
+      attr_accessor :host
+    end
+    attr_reader :response
+
     def anchor!(query)
       add_conditions!( ids_clause(query.ids) )
-    end    
+    end
 
     def size
       fetch_results if @size.nil?
@@ -26,41 +31,50 @@ class ModelSet
       @ids
     end
 
-    def config(params)
-      @config = @config ? @config.merge(params) : params
+    def use_core!(core)
+      @core = core
     end
 
-  private
-
-    def fetch_results
-      query = "#{conditions.to_s}"
-      solr_params = {:highlighting => {}}
+    def solr_params!(opts)
+      @opts = opts
+    end
 
-      if set_class.respond_to?(:solr_field_list)
-        solr_params[:field_list] = set_class.solr_field_list
+    def id_field
+      if set_class.respond_to?(:solr_id_field)
+        set_class.solr_id_field
+      else
+        'id'
       end
+    end
+
+  private
 
+    def fetch_results
+      params = @opts || {}
+      params[:q] = "#{conditions.to_s}"
+      params[:fl] ||= [id_field]
+      params[:fl] = params[:fl].join(",")
+      params[:wt] = :json
       if limit
-        solr_params[:rows]  = limit
-        solr_params[:start] = offset
+        params[:rows]  = limit
+        params[:start] = offset
       else
-        solr_params[:rows] = MAX_SOLR_RESULTS
+        params[:rows] = MAX_SOLR_RESULTS
       end
 
-      before_query(solr_params)
-      begin 
-        solr_uri = "http://" + SOLR_HOST 
-        if @config[:core]
-          solr_uri << "/" + @config[:core]
-        end
-        @response = Solr::Connection.new(solr_uri).search(query, solr_params)        
+      before_query(params)
+      begin
+        url = "http://" + self.class.host
+        url += "/" + @core if @core
+        search = RSolr.connect(:url => url)
+        @response = JSON.parse(search.get('select', :params => params))
       rescue Exception => e
-        on_exception(e, solr_params)
+        on_exception(e, params)
       end
-      after_query(solr_params)
+      after_query(params)
 
-      @count = @response.total_hits
-      @ids   = @response.hits.map{ |hit| hit[@config[:response_id_field]].to_i }
+      @count = response['response']['numFound']
+      @ids   = response['response']['docs'].collect {|doc| set_class.as_id(doc[id_field])}.to_ordered_set
       @size  = @ids.size
     end
 
@@ -69,9 +83,5 @@ class ModelSet
       field ||= 'pk_i'
       "#{field}:(#{ids.join(' OR ')})"
     end
-
-    def sanitize_condition(condition)
-      condition
-    end
   end
 end

data/lib/model_set/sphinx_query.rb

@@ -1,20 +1,17 @@
 require File.dirname(__FILE__) + '/../../vendor/sphinx_client/lib/sphinx'
-begin
-  require 'system_timer'
-rescue LoadError => e
-  module SystemTimer
-    def self.timeout(time, &block)
-      Timeout.timeout(time, &block)
-    end
-  end
-end
+require 'system_timer'
 
 class ModelSet
   class SphinxQuery < Query
-    MAX_SPHINX_RESULTS = 1000
-    MAX_QUERY_TIME     = 5
+    include Conditioned
 
-    attr_reader :conditions, :filters
+    MAX_RESULTS    = 1000
+    MAX_QUERY_TIME = 5
+
+    class << self
+      attr_accessor :host, :port
+    end
+    attr_reader :filters, :response
 
     def max_query_time
       @max_query_time || MAX_QUERY_TIME
@@ -24,6 +21,14 @@ class ModelSet
       @max_query_time = seconds
     end
 
+    def max_results
+      @max_results || MAX_RESULTS
+    end
+
+    def max_results!(max)
+      @max_results = max
+    end
+
     def anchor!(query)
       add_filters!( id_field => query.ids.to_a )
     end        
@@ -43,28 +48,20 @@ class ModelSet
       @geo = opts
     end
 
-    def add_conditions!(conditions)
-      if conditions.kind_of?(Hash)
-        conditions.each do |field, value|
-          next if value.nil?
-          field = field.join(',') if field.kind_of?(Array)
-          value = "(#{value.join('|')})" if value.kind_of?(Array)
-          add_conditions!("@(#{field}) #{value}")
-        end
-      else
-        @conditions ||= []
-        @conditions << conditions
-        @conditions.uniq!
-        clear_cache!
-      end
-    end
-
     def index
       @index ||= '*'
     end
 
-    def use_index!(index)
-      @index = index
+    def use_index!(index, opts = {})
+      if opts[:delta]
+        @index = "#{index} #{index}_delta"
+      else
+        @index = index
+      end
+    end
+
+    def select_fields!(*fields)
+      @select = fields.flatten
     end
 
     SORT_MODES = {
@@ -72,7 +69,7 @@ class ModelSet
       :descending => Sphinx::Client::SPH_SORT_ATTR_DESC,
       :ascending  => Sphinx::Client::SPH_SORT_ATTR_ASC,
       :time       => Sphinx::Client::SPH_SORT_TIME_SEGMENTS,
-      :extending  => Sphinx::Client::SPH_SORT_EXTENDED,
+      :extended   => Sphinx::Client::SPH_SORT_EXTENDED,
       :expression => Sphinx::Client::SPH_SORT_EXPR,
     }
 
@@ -86,6 +83,27 @@ class ModelSet
       clear_cache!
     end
 
+    RANKING_MODES = {
+      :proximity_bm25 => Sphinx::Client::SPH_RANK_PROXIMITY_BM25,
+      :bm25           => Sphinx::Client::SPH_RANK_BM25,
+      :none           => Sphinx::Client::SPH_RANK_NONE,
+      :word_count     => Sphinx::Client::SPH_RANK_WORDCOUNT,
+      :proximity      => Sphinx::Client::SPH_RANK_PROXIMITY,
+      :fieldmask      => Sphinx::Client::SPH_RANK_FIELDMASK,
+      :sph04          => Sphinx::Client::SPH_RANK_SPH04,
+      :total          => Sphinx::Client::SPH_RANK_TOTAL,
+    }
+
+    def rank_using!(mode_or_expr)
+      if mode_or_expr.nil?
+        @ranking = nil
+      elsif mode = RANKING_MODES[mode_or_expr]
+        @ranking = [mode]
+      else
+        @ranking = [Sphinx::Client::SPH_RANK_EXPR, mode_or_expr]
+      end
+    end
+
     def size
       fetch_results if @size.nil?
       @size
@@ -96,11 +114,23 @@ class ModelSet
       @count
     end
 
+    def total_count
+      response['total_found']
+    end
+
     def ids
       fetch_results if @ids.nil?
       @ids
     end
 
+    def id_field
+      if set_class.respond_to?(:sphinx_id_field)
+        set_class.sphinx_id_field
+      else
+        'id'
+      end
+    end
+
     class SphinxError < StandardError
       attr_accessor :opts
       def message
@@ -111,28 +141,30 @@ class ModelSet
   private
 
     def fetch_results
-      if @conditions.nil? or @empty
+      if conditions.nil? or @empty
         @count = 0
         @size  = 0
         @ids   = []
       else
         opts = {
           :filters => @filters,
-          :query   => conditions_clause,
+          :query   => conditions.to_s,
         }
         before_query(opts)
 
         search = Sphinx::Client.new
         search.SetMaxQueryTime(max_query_time * 1000)
-        search.SetServer(self.class.server_host, self.class.server_port)
+        search.SetServer(self.class.host, self.class.port)
+        search.SetSelect((@select || [id_field]).join(','))
         search.SetMatchMode(Sphinx::Client::SPH_MATCH_EXTENDED2)
         if limit
-          search.SetLimits(offset, limit, offset + limit)
+          search.SetLimits(offset, limit, max_results)
         else
-          search.SetLimits(0, MAX_SPHINX_RESULTS, MAX_SPHINX_RESULTS)
+          search.SetLimits(0, max_results, max_results)
         end
 
         search.SetSortMode(*@sort_order) if @sort_order
+        search.SetRankingMode(*@ranking) if @ranking
         search.SetFilter('class_id', model_class.class_id) if model_class.respond_to?(:class_id)
 
         if @geo
@@ -161,7 +193,7 @@ class ModelSet
         end
 
         begin
-          response = SystemTimer.timeout(max_query_time) do
+          @response = SystemTimer.timeout(max_query_time) do
             search.Query(opts[:query], index)
           end
           unless response
@@ -175,8 +207,8 @@ class ModelSet
           on_exception(e)
         end
         
-        @count = response['total_found']
-        @ids   = response['matches'].collect {|r| r['id']}.to_ordered_set
+        @count = [response['total_found'], max_results].min
+        @ids   = response['matches'].collect {|match| set_class.as_id(match[id_field])}.to_ordered_set
         @size  = @ids.size
 
         after_query(opts)
@@ -195,12 +227,26 @@ class ModelSet
       end
     end
 
-    class << self
-      attr_accessor :server_host, :server_port
+    def condition_ops
+      { :not => '-',
+        :and => ' ',
+        :or  => '|' }
     end
 
-    def conditions_clause
-      @conditions ? @conditions.join(' ') : ''
+    def transform_condition(condition)
+      if condition.kind_of?(Hash)
+        condition.collect do |field, value|
+          next if value.nil?
+          field = field.join(',') if field.kind_of?(Array)
+          if value.kind_of?(Array)
+            value = [:or, *value] unless value.first.kind_of?(Symbol)
+            value = to_conditions(*value).to_s
+          end
+          "@(#{field}) #{value}"
+        end.compact
+      else
+        condition
+      end
     end
   end
 end