ninjudd-model_set 0.9.2

data/lib/model_set/conditioned.rb

@@ -0,0 +1,33 @@
+class ModelSet
+  module Conditioned
+    # Shared methods for dealing with conditions.
+    attr_reader :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
+
+      if operator == :not
+        # In this case, :not actually means :and :not.
+        conditions = ~Conditions.new(:and, *conditions)
+        operator   = :and
+      end
+
+      conditions << @conditions if @conditions
+      @conditions = Conditions.new(operator, *conditions)
+
+      clear_cache!
+    end
+
+    def invert!
+      raise 'cannot invert without conditions' if @conditions.nil?
+      @conditions = ~@conditions
+      clear_cache!
+    end
+  end
+end

data/lib/model_set/conditions.rb

@@ -0,0 +1,103 @@
+class ModelSet
+  class Conditions
+    deep_clonable
+
+    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)] 
+        else
+          # Compact the conditions if possible.
+          @conditions = []
+          args.each do |clause|
+            self << clause
+          end
+        end
+      end
+    end
+
+    def terminal?
+      operator.nil?
+    end
+
+    def <<(clause)
+      raise 'cannot append conditions to a terminal' if terminal?
+      
+      clause = self.class.new(clause) 
+      if clause.operator == operator
+        @conditions.concat(clause.conditions)
+      else
+        @conditions << clause
+      end
+      @conditions.uniq!
+    end
+
+    def ~
+      if operator == :not
+        conditions.first.clone
+      else
+        new(:not, self)
+      end
+    end
+
+    def |(other)
+      new(:or, self, other)
+    end
+
+    def &(other)
+      new(:and, self, other)
+    end
+
+    def to_s
+      return conditions.first if terminal?
+
+      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 ')}"
+      end
+    end
+
+    def hash
+      # for uniq
+      [operator, conditions].hash
+    end
+
+    def eql?(other)
+      # for uniq
+      self.hash == other.hash
+    end
+  end
+end

data/lib/model_set/query.rb

@@ -0,0 +1,128 @@
+class ModelSet
+  class Query
+    deep_clonable
+
+    def initialize(model_set = ModelSet)
+      if model_set.kind_of?(Class)
+        @set_class = model_set
+      else
+        @set_class = model_set.class
+        anchor!(model_set.query) if model_set.query
+      end
+    end
+
+    def order_by!(order)
+      @sort_order = order
+      clear_cache!
+    end
+
+    def unsorted!
+      @sort_order = nil
+      clear_cache!
+    end
+
+    def page!(page)
+      @page   = page ? page.to_i : nil
+      @offset = nil
+      clear_limited_cache!
+    end
+
+    def limit!(limit, offset = nil)
+      @limit  = limit  ? limit.to_i  : nil
+      @offset = offset ? offset.to_i : nil
+      @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, :id_field_with_prefix, :to => :set_class
+
+    def model_class
+      set_class.query_model_class
+    end
+
+    def model_name
+      model_class.name
+    end
+
+    def table_name
+      model_class.table_name
+    end
+
+    attr_reader :limit, :sort_order
+
+    def offset
+      if limit
+        @offset ||= @page ? (@page - 1) * limit : 0
+      end
+    end
+
+    def page
+      if limit
+        @page ||= @offset ? (@offset / limit) : 1
+      end
+    end
+
+    def pages
+      limit ? (1.0 * count / limit).ceil : 1
+    end
+
+    def before_query(*args)
+      proc = self.class.before_query
+      proc.bind(self).call(*args) if proc
+    end
+    
+    def self.before_query(&block)
+      if block
+        @before_query = block
+      else
+        @before_query
+      end
+    end
+
+    def on_exception(*args)
+      proc = self.class.on_exception
+      proc ? proc.bind(self).call(*args) : raise(args.first)
+    end
+
+    def self.on_exception(&block)
+      if block
+        @on_exception = block
+      else
+        @on_exception
+      end
+    end
+
+    def after_query(*args)
+      proc = self.class.after_query
+      proc.bind(self).call(*args) if proc
+    end
+
+    def self.after_query(*args, &block)
+      if block
+        @after_query = block
+      else
+        @after_query
+      end
+    end
+
+  end
+end

data/lib/model_set/raw_query.rb

@@ -0,0 +1,41 @@
+class ModelSet
+  class RawQuery < Query
+    attr_reader :records
+
+    def anchor!(query, raw_method = 'find_raw_by_id')
+      @records = model_class.send(raw_method, query.ids.to_a)
+    end
+
+    def select!(&block)
+      records.select!(&block)
+    end
+
+    def reject!(&block)
+      records.reject!(&block)
+    end
+
+    def sort_by!(&block)
+      @records = records.sort_by(&block)
+    end
+
+    def ids
+      if limit
+        (records[offset, limit] || []).collect {|r| r['id'].to_i}
+      else
+        records.collect {|r| r['id'].to_i}
+      end
+    end
+    
+    def size
+      if limit
+        [count - offset, limit].min
+      else
+        count
+      end
+    end
+
+    def count
+      records.size
+    end
+  end
+end

data/lib/model_set/raw_sql_query.rb

@@ -0,0 +1,19 @@
+class ModelSet
+  class RawSQLQuery < SQLBaseQuery
+    def sql=(sql)
+      @sql = sanitize_condition(sql)
+      ['LIMIT', 'OFFSET'].each do |term|
+        raise "#{term} not permitted in raw sql" if @sql.match(/ #{term} \d+/i)
+      end
+    end
+    
+    def sql
+      "#{@sql} #{limit_clause}"
+    end
+
+    def count
+      # The only way to get the count if there is a limit is to fetch all ids without the limit.
+      @count ||= limit ? fetch_id_set(@sql).size : size
+    end
+  end
+end

data/lib/model_set/set_query.rb

@@ -0,0 +1,34 @@
+class ModelSet
+  class SetQuery < Query
+    delegate :add!, :unshift!, :subtract!, :intersect!, :reorder!, :to => :set
+
+    def anchor!(query)
+      @set = query.ids.to_ordered_set
+    end
+
+    def set
+      @set ||= [].to_ordered_set
+    end
+
+    def ids
+      if limit
+        set.limit(limit, offset)
+      else
+        set.clone
+      end
+    end
+    
+    def size
+      if limit
+        [count - offset, limit].min
+      else
+        count
+      end
+    end
+
+    def count
+      set.size
+    end
+    
+  end
+end

data/lib/model_set/solr_query.rb

@@ -0,0 +1,70 @@
+class ModelSet
+  class SolrQuery < Query
+    include Conditioned
+
+    MAX_SOLR_RESULTS = 1000
+
+    def anchor!(query)
+      add_conditions!( ids_clause(query.ids) )
+    end    
+
+    def size
+      fetch_results if @size.nil?
+      @size
+    end
+
+    def count
+      fetch_results if @count.nil?
+      @count
+    end
+
+    def ids
+      fetch_results if @ids.nil?
+      @ids
+    end
+
+  private
+
+    def fetch_results
+      query = "#{conditions.to_s};#{@sort_order.to_s}"
+      
+      solr_params = []
+      solr_params << "q=#{ ERB::Util::url_encode(query) }"
+      solr_params << "wt=ruby"
+      solr_params << "fl=pk_i"
+      
+      if limit
+        solr_params << "rows=#{limit}"
+        solr_params << "start=#{offset}"
+      else
+        solr_params << "rows=#{MAX_SOLR_RESULTS}"
+      end
+      
+      solr_params = solr_params.join('&')
+      before_query(solr_params)
+      
+      # Catch any errors when calling solr so we can log the params.
+      begin
+        resp = eval ActsAsSolr::Post.execute(solr_params)
+      rescue Exception => e
+        on_exception(e, solr_params)
+      end
+
+      after_query(solr_params)
+      
+      @count = resp['response']['numFound']
+      @ids   = resp['response']['docs'].collect {|doc| doc['pk_i'].to_i}.to_ordered_set
+      @size  = @ids.size
+    end
+
+    def ids_clause(ids, field = nil)
+      return 'pk_i:(false)' if ids.empty?
+      field ||= 'pk_i'
+      "#{field}:(#{ids.join(' OR ')})"
+    end
+
+    def sanitize_condition(condition)
+      condition
+    end
+  end
+end

data/lib/model_set/sphinx_query.rb

@@ -0,0 +1,148 @@
+require File.dirname(__FILE__) + '/../../vendor/sphinx_client/lib/sphinx'
+
+class ModelSet
+  class SphinxQuery < Query
+    MAX_SPHINX_RESULTS = 1000
+
+    class SphinxError < StandardError; end
+
+    attr_reader :conditions, :filters
+
+    def anchor!(query)
+      add_filters!( id_field => query.ids.to_a )
+    end    
+
+    def add_filters!(filters)
+      @filters ||= {}
+      @filters.merge!(filters)
+      clear_cache!
+    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)
+          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
+    end
+
+    SORT_MODES = {
+      :relevance  => Sphinx::Client::SPH_SORT_RELEVANCE,
+      :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,
+      :expression => Sphinx::Client::SPH_SORT_EXPR,
+    }
+
+    def order_by!(field, mode = :ascending)
+      raise "invalid mode: :#{mode}" unless SORT_MODES[mode]
+      @sort_order = [SORT_MODES[mode], field.to_s]
+      clear_cache!
+    end
+
+    def size
+      fetch_results if @size.nil?
+      @size
+    end
+
+    def count
+      fetch_results if @count.nil?
+      @count
+    end
+
+    def ids
+      fetch_results if @ids.nil?
+      @ids
+    end
+
+  private
+
+    def fetch_results
+      if @conditions.nil? or (@filters and @filters[id_field] and @filters[id_field].empty?)
+        @count = 0
+        @size  = 0
+        @ids   = []
+      else
+        opts = {
+          :filters => @filters,
+          :query   => conditions_clause,
+        }
+        before_query(opts)
+
+        search = Sphinx::Client.new
+        search.SetServer(self.class.server_host, self.class.server_port)
+        search.SetMatchMode(Sphinx::Client::SPH_MATCH_EXTENDED2)
+        if limit
+          search.SetLimits(offset, limit, offset + limit)
+        else
+          search.SetLimits(0, MAX_SPHINX_RESULTS, MAX_SPHINX_RESULTS)
+        end
+        search.SetSortMode(*@sort_order) if @sort_order
+        search.SetFilter('class_id', model_class.class_id) if model_class.respond_to?(:class_id)
+
+        @filters and @filters.each do |field, value|
+          next if value.nil?
+
+          exclude = defined?(AntiObject) && value.kind_of?(AntiObject)
+          value = ~value if exclude
+
+          if value.kind_of?(Range)
+            min, max = filter_values([value.begin, value.end])
+            search.SetFilterRange(field.to_s, min, max, exclude)
+          else
+            search.SetFilter(field.to_s, filter_values(value), exclude)
+          end
+        end
+
+        begin
+          response = search.Query(opts[:query], index)
+          raise SphinxError, search.GetLastError unless response
+        rescue Exception => e
+          on_exception(e, opts)
+        end
+        
+        @count = response['total_found']
+        @ids   = response['matches'].collect {|r| r['id']}.to_ordered_set
+        @size  = @ids.size
+        
+        after_query(opts)
+      end
+    end
+    
+    def filter_values(values)
+      Array(values).collect do |value|
+        case value
+        when Date       : value.to_time.to_i
+        when TrueClass  : 1
+        when FalseClass : 0
+        else
+          value.to_i
+        end
+      end
+    end
+
+    class << self
+      attr_accessor :server_host, :server_port
+    end
+
+    def conditions_clause
+      @conditions ? @conditions.join(' ') : ''
+    end
+  end
+end