model_set 0.10.6

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Justin Balthrop
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,39 @@
+= ModelSet
+
+ModelSet is a array-like class for dealing with sets of ActiveRecord models. ModelSet
+stores a list of ids and fetches the models lazily only when necessary. You can also add
+conditions in SQL to further limit the set. Currently I support alternate queries using
+the Solr search engine through a subclass, but I plan to abstract this out into a "query
+engine" class that will support SQL, Solr, Sphinx, and eventually, other query methods
+(possibly raw RecordCache hashes and other search engines).
+
+== Usage:
+
+  class RobotSet < ModelSet
+  end
+  
+  set1 = RobotSet.new([1,2,3,4]) # doesn't fetch the models
+  
+  set1.each do |model| # fetches all 
+    # do something
+  end
+  
+  set2 = RobotSet.new([1,2])
+  
+  set3 = set1 - set2
+  set3.ids
+  # => [3,4]
+  
+  set3 << Robot.find(5)
+  set3.ids
+  # => [3,4,5]
+
+== Install:
+
+  sudo gem install ninjudd-deep_clonable -s http://gems.github.com
+  sudo gem install ninjudd-ordered_set -s http://gems.github.com
+  sudo gem install ninjudd-model_set -s http://gems.github.com
+
+== License:
+
+Copyright (c) 2009 Justin Balthrop, Geni.com; Published under The MIT License, see LICENSE

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:build: 
+:patch: 6
+:major: 0
+:minor: 10

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,132 @@
+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_enabled?
+      true # Override if limit is not possible for subclass.
+    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!, :reverse!, :reverse_reorder!, :shuffle!, :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,206 @@
+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
+
+class ModelSet
+  class SphinxQuery < Query
+    MAX_SPHINX_RESULTS = 1000
+    MAX_QUERY_TIME     = 5
+
+    attr_reader :conditions, :filters
+
+    def max_query_time
+      @max_query_time || MAX_QUERY_TIME
+    end
+
+    def max_query_time!(seconds)
+      @max_query_time = seconds
+    end
+
+    def anchor!(query)
+      add_filters!( id_field => query.ids.to_a )
+    end        
+
+    def add_filters!(filters)
+      @filters ||= []
+
+      filters.each do |key, value|
+        next if value.nil?
+        @empty = true if value.kind_of?(Array) and value.empty?
+        @filters << [key, value]
+      end
+      clear_cache!
+    end
+
+    def geo_anchor!(opts)
+      @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.collect {|v| '"' + v + '"'}.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
+    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)
+      if field == :relevance
+        @sort_order = [SORT_MODES[:relevance]]
+      else
+        raise "invalid mode: :#{mode}" unless SORT_MODES[mode]
+        @sort_order = [SORT_MODES[mode], field.to_s]
+      end
+      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
+
+    class SphinxError < StandardError
+      attr_accessor :opts
+      def message
+        "#{super}: #{opts.inspect}"
+      end
+    end
+
+  private
+
+    def fetch_results
+      if @conditions.nil? or @empty
+        @count = 0
+        @size  = 0
+        @ids   = []
+      else
+        opts = {
+          :filters => @filters,
+          :query   => conditions_clause,
+        }
+        before_query(opts)
+
+        search = Sphinx::Client.new
+        search.SetMaxQueryTime(max_query_time * 1000)
+        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)
+
+        if @geo
+          # Latitude and longitude in radians, radius in meters.
+          lat_field  = @geo[:latitude_field]  || "#{@geo[:prefix]}_latitude"
+          long_field = @geo[:longitude_field] || "#{@geo[:prefix]}_longitude"
+
+          search.SetGeoAnchor(lat_field, long_field, @geo[:latitude].to_f, @geo[:longitude].to_f)
+          search.SetFloatRange('@geodist', 0.0, @geo[:radius].to_f)
+        end
+
+        @filters and @filters.each do |field, value|
+          exclude = defined?(AntiObject) && value.kind_of?(AntiObject)
+          value = ~value if exclude
+
+          if value.kind_of?(Range)
+            min, max = filter_values([value.begin, value.end])
+            if min.kind_of?(Float) or max.kind_of?(Float)
+              search.SetFilterFloatRange(field.to_s, min.to_f, max.to_f, exclude)
+            else
+              search.SetFilterRange(field.to_s, min, max, exclude)
+            end
+          else
+            search.SetFilter(field.to_s, filter_values(value), exclude)
+          end
+        end
+
+        begin
+          response = SystemTimer.timeout(max_query_time) do
+            search.Query(opts[:query], index)
+          end
+          unless response
+            e = SphinxError.new(search.GetLastError)
+            e.opts = opts
+            raise e
+          end
+        rescue Exception => e
+          e = SphinxError.new(e) unless e.kind_of?(SphinxError)
+          e.opts = opts
+          on_exception(e)
+        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