supernova 0.2.2 → 0.3.0

data/TODO

@@ -0,0 +1,3 @@
+- mapping von dynamic zu static fields in load_document
+- setzen von solr_row in load document
+- speichern von :type in :type_s

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.0

data/lib/supernova.rb

@@ -24,6 +24,8 @@ module Supernova
 end
 
 require "supernova/numeric_extensions"
+require "supernova/symbol_extensions"
+require "supernova/condition"
 require "supernova/collection"
 require "supernova/criteria"
 require "supernova/thinking_sphinx"

data/lib/supernova/condition.rb

@@ -0,0 +1,27 @@
+class Supernova::Condition
+  attr_accessor :key, :type
+  
+  def initialize(key, type)
+    self.key = key
+    self.type = type
+  end
+  
+  def solr_filter_for(value)
+    case type
+      when :not, :ne
+        if value.nil?
+          "#{self.key}:[* TO *]"
+        else
+          "!#{self.key}:#{value}"
+        end
+      when :gt
+        "#{self.key}:{#{value} TO *}"
+      when :gte
+        "#{self.key}:[#{value} TO *]"
+      when :lt
+        "#{self.key}:{* TO #{value}}"
+      when :lte
+        "#{self.key}:[* TO #{value}]"
+    end
+  end
+end

data/lib/supernova/criteria.rb

@@ -28,6 +28,10 @@ class Supernova::Criteria
   def for_classes(clazzes)
     merge_filters :classes, [clazzes].flatten
   end
+  
+  def attribute_mapping(mapping)
+    merge_search_options :attribute_mapping, mapping
+  end
 
   def order(order_option)
     merge_search_options :order, order_option
@@ -41,14 +45,18 @@ class Supernova::Criteria
     merge_search_options :group_by, group_option
   end
 
-  def search(query)
-    merge_filters :search, query
+  def search(*terms)
+    merge_filters_array :search, terms
   end
 
   def with(filters)
     merge_filters :with, filters
   end
   
+  def where(*args)
+    with(*args)
+  end
+  
   def without(filters)
     self.filters[:without] ||= Hash.new
     filters.each do |key, value|
@@ -59,11 +67,7 @@ class Supernova::Criteria
   end
 
   def select(*fields)
-    self.search_options[:select] ||= Array.new
-    fields.flatten.each do |field|
-      self.search_options[:select] << field if !self.search_options[:select].include?(field)
-    end
-    self
+    merge_filters_array :select, fields
   end
 
   def conditions(filters)
@@ -105,6 +109,14 @@ class Supernova::Criteria
   def merge_filters(key, value)
     merge_filters_or_search_options(self.filters, key, value)
   end
+  
+  def merge_filters_array(key, fields)
+    self.search_options[key] ||= Array.new
+    fields.flatten.each do |field|
+      self.search_options[key] << field if !self.search_options[key].include?(field)
+    end
+    self
+  end
 
   def merge_search_options(key, value)
     merge_filters_or_search_options(self.search_options, key, value)

data/lib/supernova/solr_criteria.rb

@@ -1,26 +1,29 @@
 require "rsolr"
 
 class Supernova::SolrCriteria < Supernova::Criteria
+  # move this into separate methods (test each separatly)
   def to_params
     solr_options = { :fq => [], :q => "*:*" }
-    solr_options[:fq] += self.filters[:with].map { |key, value| "#{key}:#{value}" } if self.filters[:with]
+    solr_options[:fq] += fq_from_with(self.filters[:with])
     if self.filters[:without]
-     self.filters[:without].each do |key, values| 
-       solr_options[:fq] += values.map { |value| "!#{key}:#{value}" }
+     self.filters[:without].each do |field, values| 
+       solr_options[:fq] += values.map { |value| "!#{solr_field_from_field(field)}:#{value}" }
      end
     end
-    solr_options[:sort] = self.search_options[:order] if self.search_options[:order]
-    solr_options[:q] = self.filters[:search] if self.filters[:search]
+    solr_options[:sort] = convert_search_order(self.search_options[:order]) if self.search_options[:order]
+    if self.search_options[:search].is_a?(Array)
+      solr_options[:q] = self.search_options[:search].map { |query| "(#{query})" }.join(" AND ")
+    end
     
     if self.search_options[:geo_center] && self.search_options[:geo_distance]
       solr_options[:pt] = "#{self.search_options[:geo_center][:lat]},#{self.search_options[:geo_center][:lng]}"
       solr_options[:d] = self.search_options[:geo_distance].to_f / Supernova::KM_TO_METER
-      solr_options[:sfield] = :location
+      solr_options[:sfield] = solr_field_from_field(:location)
       solr_options[:fq] << "{!geofilt}"
     end
     if self.search_options[:select]
       self.search_options[:select] << :id
-      solr_options[:fl] = self.search_options[:select].compact.join(",") 
+      solr_options[:fl] = self.search_options[:select].compact.map { |field| solr_field_from_field(field) }.join(",") 
     end
     solr_options[:fq] << "type:#{self.clazz}" if self.clazz
     
@@ -31,6 +34,39 @@ class Supernova::SolrCriteria < Supernova::Criteria
     solr_options
   end
   
+  def convert_search_order(order)
+    asc_or_desc = nil
+    field = solr_field_from_field(order)
+    if order.match(/^(.*?) (asc|desc)/i)
+      field = solr_field_from_field($1)
+      asc_or_desc = $2
+    end
+    [field, asc_or_desc].compact.join(" ")
+  end
+  
+  def solr_field_from_field(field)
+    Supernova::SolrIndexer.solr_field_for_field_name_and_mapping(field, search_options[:attribute_mapping])
+  end
+  
+  def fq_from_with(with)
+    if with.blank?
+      []
+    else
+      with.map do |key_or_condition, value|
+        if key_or_condition.respond_to?(:solr_filter_for)
+          key_or_condition.key = solr_field_from_field(key_or_condition.key)
+          key_or_condition.solr_filter_for(value)
+        else
+          fq_filter_for_key_and_value(solr_field_from_field(key_or_condition), value)
+        end
+      end
+    end
+  end
+  
+  def fq_filter_for_key_and_value(key, value)
+    "#{key}:#{value.is_a?(Range) ? "[#{value.first} TO #{value.last}]" : value}"
+  end
+  
   def build_docs(docs)
     docs.map do |hash|
       self.search_options[:build_doc_method] ? self.search_options[:build_doc_method].call(hash) : build_doc(hash)
@@ -42,8 +78,9 @@ class Supernova::SolrCriteria < Supernova::Criteria
   end
   
   def build_doc(hash)
-    return hash if hash["type"].nil?
+    return hash if !hash["type"].respond_to?(:constantize)
     doc = hash["type"].constantize.new
+    doc.instance_variable_set("@solr_doc", hash)
     hash.each do |key, value|
       if key == "id"
         doc.id = value.to_s.split("/").last if doc.respond_to?(:id=)

data/lib/supernova/solr_indexer.rb

@@ -1,14 +1,129 @@
 require "json"
 
 class Supernova::SolrIndexer
-  attr_accessor :options, :db
+  attr_accessor :options, :db, :ids
   attr_writer :index_file_path
   
+  class << self
+    def field_definitions
+      @field_definitions ||= {}
+    end
+    
+    def has(key, attributes)
+      field_definitions[key] = attributes
+    end
+    
+    def clazz(class_name =:only_return)
+      @clazz = class_name if class_name != :only_return
+      @clazz
+    end
+    
+    def table_name(name = :only_return)
+      @table_name = name if name != :only_return
+      @table_name
+    end
+    
+    def method_missing(*args)
+      criteria = Supernova::SolrCriteria.new(self.clazz).attribute_mapping(self.field_definitions)
+      if criteria.respond_to?(args.first)
+        criteria.send(*args)
+      else
+        super
+      end
+    end
+  end
+  
+  FIELD_SUFFIX_MAPPING = {
+    :raw => nil,
+    :string => :s,
+    :text => :t,
+    :int => :i,
+    :integer => :i,
+    :sint => :si,
+    :float => :f,
+    :date => :dt,
+    :boolean => :b,
+    :location => :p
+  }
+  
   def initialize(options = {})
     options.each do |key, value|
       self.send(:"#{key}=", value) if self.respond_to?(:"#{key}=")
     end
     self.options = options
+    self.ids ||= :all
+  end
+  
+  def index!
+    index_query(query_to_index) do |row|
+      row_to_solr(row)
+    end
+  end
+  
+  def row_to_solr(row)
+    row
+  end
+  
+  def table_name
+    self.class.table_name || (self.class.clazz && self.class.clazz.respond_to?(:table_name) ? self.class.clazz.table_name : nil)
+  end
+  
+  def query_to_index
+    raise "no table_name defined" if self.table_name.nil?
+    query = "SELECT #{select_fields.join(", ")} FROM #{self.table_name}"
+    query << " WHERE id IN (#{ids.join(", ")})" if ids_given?
+    query
+  end
+  
+  def default_fields
+    fields = ["id"]
+    fields << %("#{self.class.clazz}" AS type_s) if self.class.clazz
+    fields
+  end
+  
+  def defined_fields
+    self.class.field_definitions.map do |field, options|
+      sql_column_from_field_and_type(field, options[:type]) if options[:virtual] != true
+    end.compact
+  end
+  
+  def select_fields
+    default_fields + defined_fields
+  end
+  
+  def validate_lat(lat)
+    float_or_nil_when_abs_bigger_than(lat, 90)
+  end
+  
+  def validate_lng(lng)
+    float_or_nil_when_abs_bigger_than(lng, 180)
+  end
+  
+  def float_or_nil_when_abs_bigger_than(value, border)
+    return nil if value.to_s.strip.length == 0
+    value_f = value.to_f
+    value_f.abs > border ? nil : value_f
+  end
+  
+  def sql_column_from_field_and_type(field, type)
+    return sql_date_column_from_field(field) if type == :date
+    if suffix = self.class.suffix_from_type(type)
+      "#{field} AS #{field}_#{suffix}"
+    else
+      raise "no suffix for #{type} defined"
+    end
+  end
+  
+  def self.suffix_from_type(type)
+    FIELD_SUFFIX_MAPPING[type.to_sym]
+  end
+  
+  def self.solr_field_for_field_name_and_mapping(field, mapping)
+    [field, mapping && mapping[field.to_sym] ? suffix_from_type(mapping[field.to_sym][:type]) : nil].compact.join("_")
+  end
+  
+  def sql_date_column_from_field(field)
+    %(IF(#{field} IS NULL, NULL, CONCAT(REPLACE(#{field}, " ", "T"), "Z")) AS #{field}_dt)
   end
   
   def query_db(query)
@@ -23,6 +138,10 @@ class Supernova::SolrIndexer
     finish
   end
   
+  def ids_given?
+    self.ids.is_a?(Array)
+  end
+  
   def index_file_path
     @index_file_path ||= File.expand_path("/tmp/index_file_#{Time.now.to_i}.json")
   end

data/lib/supernova/symbol_extensions.rb

@@ -0,0 +1,7 @@
+Symbol.class_eval do
+  [:not, :gt, :gte, :lt, :lte, :ne].each do |method|
+    define_method(method) do
+      Supernova::Condition.new(self, method)
+    end
+  end
+end

data/lib/supernova/thinking_sphinx_criteria.rb

@@ -31,7 +31,7 @@ class Supernova::ThinkingSphinxCriteria < Supernova::Criteria
       sphinx_options[:geo] = [self.search_options[:geo_center][:lat].to_radians, self.search_options[:geo_center][:lng].to_radians]
       sphinx_options[:with]["@geodist"] = self.search_options[:geo_distance].is_a?(Range) ? self.search_options[:geo_distance] : Range.new(0.0, self.search_options[:geo_distance])
     end
-    [self.filters[:search], sphinx_options]
+    [(self.search_options[:search] || Array.new).join(" "), sphinx_options]
   end
   
   def to_a

data/spec/integration/solr_spec.rb

@@ -7,12 +7,14 @@ describe "Solr" do
     Supernova::Solr.truncate!
     Offer.criteria_class = Supernova::SolrCriteria
     root = Geokit::LatLng.new(47, 11)
-    endpoint = root.endpoint(90, 50, :units => :kms)
+    # endpoint = root.endpoint(90, 50, :units => :kms)
+    e_lat = 46.9981112912042
+    e_lng = 11.6587158814378
     Supernova::Solr.connection.add(:id => "offers/1", :type => "Offer", :user_id => 1, :enabled => false, :text => "Hans Meyer", :popularity => 10, 
       :location => "#{root.lat},#{root.lng}", :type => "Offer"
     )
     Supernova::Solr.connection.add(:id => "offers/2", :user_id => 2, :enabled => true, :text => "Marek Mintal", :popularity => 1, 
-      :location => "#{endpoint.lat},#{endpoint.lng}", :type => "Offer"
+      :location => "#{e_lat},#{e_lng}", :type => "Offer"
     )
     Supernova::Solr.connection.commit
   end
@@ -44,6 +46,25 @@ describe "Solr" do
       new_criteria.to_a.per_page.should == 25
     end
     
+    describe "plain text search" do
+      it "returns the correct entries for 1 term" do
+        new_criteria.search("Hans").to_a.map { |h| h["id"] }.should == [1]
+        new_criteria.search("Hans").search("Meyer").to_a.map { |h| h["id"] }.should == [1]
+        new_criteria.search("Marek").to_a.map { |h| h["id"] }.should == [2]
+      end
+      
+      it "returns the correct options for a combined search" do
+        new_criteria.search("Hans", "Marek").to_a.map.should == []
+      end
+    end
+    
+    it "includes the returned solr_doc" do
+      new_criteria.search("Hans").to_a.first.instance_variable_get("@solr_doc").should == {
+        "id" => "offers/1", "type" => "Offer", "user_id" => 1, "enabled" => [false], "text" => "Hans Meyer", "popularity" => 10, 
+        "location" => "47,11", "type" => "Offer"
+      }
+    end
+    
     describe "nearby search" do
       { 49.kms => 1, 51.kms => 2 }.each do |distance, total_entries|
         it "returns #{total_entries} for distance #{distance}" do
@@ -52,6 +73,37 @@ describe "Solr" do
       end
     end
     
+    describe "range search" do
+      { Range.new(2, 3) => [2], Range.new(3, 10) => [], Range.new(1, 2) => [1, 2] }.each do |range, ids|
+        it "returns #{ids.inspect} for range #{range.inspect}" do
+          new_criteria.with(:user_id => range).map { |doc| doc["id"] }.sort.should == ids
+        end
+      end
+    end
+    
+    describe "not searches" do
+      it "finds the correct documents for not nil" do
+        Supernova::Solr.connection.add(:id => "offers/3", :enabled => true, :text => "Marek Mintal", :popularity => 1, 
+          :type => "Offer"
+        )
+        Supernova::Solr.connection.commit
+        raise "There should be 3 docs" if new_criteria.to_a.total_entries != 3
+        new_criteria.with(:user_id.not => nil).to_a.map { |h| h["id"] }.should == [1, 2]
+      end
+      
+      it "finds the correct values for not specific value" do
+        new_criteria.with(:user_id.not => 1).to_a.map { |h| h["id"] }.should == [2]
+      end
+    end
+    
+    describe "gt and lt searches" do
+      { :gt => [2], :gte => [1, 2], :lt => [], :lte => [1] }.each do |type, ids|
+        it "finds ids #{ids.inspect} for #{type}" do
+          new_criteria.with(:user_id.send(type) => 1).to_a.map { |row| row["id"] }.sort.should == ids
+        end
+      end
+    end
+    
     it "returns the correct objects" do
       new_criteria.with(:user_id => 1).to_a.first.should be_an_instance_of(Offer)
     end

data/spec/integration/thinking_sphinx_spec.rb

@@ -23,7 +23,7 @@ describe "ThinkingSphinx" do
     @offer1 = Offer.create!(:id => 1, :user_id => 1, :enabled => false, :text => "Hans Meyer", :popularity => 10, :lat => root.lat, :lng => root.lng)
     @offer2 = Offer.create!(:id => 2, :user_id => 2, :enabled => true, :text => "Marek Mintal", :popularity => 1, :lat => endpoint.lat, :lng => endpoint.lng)
     ts.controller.index
-    sleep 0.1
+    sleep 0.2
   end
   
   it "finds the correct objects" do

data/spec/supernova/condition_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "Supernova::Condition" do
+  it "can be initialize" do
+    cond = Supernova::Condition.new(:user_id, :not)
+    cond.key.should == :user_id
+    cond.type.should == :not
+  end
+  
+  describe "solr_filter_for" do
+    it "returns the correct filter for numbers" do
+      :user_id.not.solr_filter_for(7).should == "!user_id:7"
+    end
+    
+    it "returns the correct filter for numbers" do
+      :user_id.ne.solr_filter_for(7).should == "!user_id:7"
+    end
+    
+    it "returns the correct filter for not nil" do
+      :user_id.not.solr_filter_for(nil).should == "user_id:[* TO *]"
+    end
+    
+    it "returns the correct filter for gt" do
+      :user_id.gt.solr_filter_for(1).should == "user_id:{1 TO *}"
+    end
+    
+    it "returns the correct filter for gte" do
+      :user_id.gte.solr_filter_for(1).should == "user_id:[1 TO *]"
+    end
+    
+    it "returns the correct filter for lt" do
+      :user_id.lt.solr_filter_for(1).should == "user_id:{* TO 1}"
+    end
+    
+    it "returns the correct filter for lt" do
+      :user_id.lte.solr_filter_for(1).should == "user_id:[* TO 1]"
+    end
+  end
+  
+  
+end

data/spec/supernova/criteria_spec.rb

@@ -59,7 +59,7 @@ describe "Supernova::Criteria" do
   
   describe "#search" do
     it "sets the query" do
-      scope.search("title").filters[:search].should == "title"
+      scope.search("title").search_options[:search].should == ["title"]
     end
   end
   
@@ -180,6 +180,21 @@ describe "Supernova::Criteria" do
     end
   end
   
+  describe "#where" do
+    it "delegates to with" do
+      ret = double("ret")
+      scope.should_receive(:with).with(:a => 9).and_return ret
+      scope.where(:a => 9).should == ret
+    end
+  end
+  
+  describe "#attribute_mapping" do
+    it "sets the attribute_mapping option" do
+      mapping = { :title => { :type => :integer } }
+      scope.attribute_mapping(mapping).search_options[:attribute_mapping].should == mapping
+    end
+  end
+  
   describe "#merge" do
     let(:criteria) { Supernova::Criteria.new.order("popularity asc").with(:a => 1).conditions(:b => 2).search("New Search") }
     let(:new_crit) { Supernova::Criteria.new.order("popularity desc").with(:c => 8).conditions(:e => 9).search("Search") }
@@ -201,7 +216,7 @@ describe "Supernova::Criteria" do
     end
     
     it "merges search search" do
-      new_crit.merge(criteria).filters[:search].should == "New Search"
+      new_crit.merge(criteria).search_options[:search].should == ["New Search"]
     end
     
     it "calls merge on options" do

data/spec/supernova/solr_criteria_spec.rb

@@ -19,6 +19,16 @@ describe Supernova::SolrCriteria do
     Supernova::Solr.stub!(:connection).and_return rsolr
   end
   
+  describe "#fq_from_with" do
+    it "returns the correct filter for with ranges" do
+      criteria.fq_from_with(:user_id => Range.new(10, 12)).should == ["user_id:[10 TO 12]"]
+    end
+    
+    it "returns the correct filter for not queries" do
+      criteria.fq_from_with(:user_id.not => nil).should == ["user_id:[* TO *]"]
+    end
+  end
+  
   describe "#to_params" do
     it "returns a Hash" do
       criteria.to_params.should be_an_instance_of(Hash)
@@ -36,10 +46,26 @@ describe Supernova::SolrCriteria do
       criteria.order("title").to_params[:sort].should == "title"
     end
     
+    it "uses a mapped field for order" do
+      criteria.attribute_mapping(:title => { :type => :string }).order("title").to_params[:sort].should == "title_s"
+    end
+    
+    %w(asc desc).each do |order|
+      it "uses a mapped field for order even when #{order} is present" do
+        criteria.attribute_mapping(:title => { :type => :string }).order("title #{order}").to_params[:sort].should == "title_s #{order}"
+      end
+    end
+    
+    
     it "sets search correct search query" do
-      criteria.search("some query").to_params[:q].should == "some query"
+      criteria.search("some query").to_params[:q].should == "(some query)"
     end
     
+    it "joins the search terms with AND" do
+      criteria.search("some", "query").to_params[:q].should == "(some) AND (query)"
+    end
+    
+    # fix me: use type_s
     it "adds a filter on type when clazz set" do
       Supernova::SolrCriteria.new(Offer).to_params[:fq].should == ["type:#{Offer}"]
     end
@@ -52,11 +78,23 @@ describe Supernova::SolrCriteria do
       criteria.select(:user_id).select(:user_id).select(:enabled).to_params[:fl].should == "user_id,enabled,id"
     end
     
+    it "uses mapped fields for select" do
+      mapping = {
+        :user_id => { :type => :integer },
+        :enabled => { :type => :boolean }
+      }
+      criteria.attribute_mapping(mapping).select(:user_id, :enabled).to_params[:fl].should == "user_id_i,enabled_b,id"
+    end
+    
     it "adds all without filters" do
       criteria.without(:user_id => 1).to_params[:fq].should == ["!user_id:1"]
       criteria.without(:user_id => 1).without(:user_id => 1).without(:user_id => 2).to_params[:fq].sort.should == ["!user_id:1", "!user_id:2"]
     end
     
+    it "uses mapped fields for without" do
+      criteria.attribute_mapping(:user_id => { :type => :integer }).without(:user_id => 1).to_params[:fq].should == ["!user_id_i:1"]
+    end
+    
     describe "with a nearby search" do
       let(:nearby_criteria) { Supernova::SolrCriteria.new.near(47, 11).within(10.kms) }
       
@@ -69,7 +107,11 @@ describe Supernova::SolrCriteria do
       end
       
       it "sets the sfield to location" do
-        nearby_criteria.to_params[:sfield].should == :location
+        nearby_criteria.to_params[:sfield].should == "location"
+      end
+      
+      it "uses the mapped field when mapping defined" do
+        nearby_criteria.attribute_mapping(:location => { :type => :location }).to_params[:sfield].should == "location_p"
       end
       
       it "sets the fq field to {!geofilt}" do
@@ -94,6 +136,30 @@ describe Supernova::SolrCriteria do
         criteria.paginate(:per_page => 10, :page => 2).to_params[:start].should == 10
       end
     end
+    
+    describe "with attribute mapping" do
+      it "uses the mapped fields" do
+        criteria.attribute_mapping(:artist_name => { :type => :string }).where(:artist_name => "test").to_params[:fq].should == ["artist_name_s:test"]
+      end
+      
+      it "uses the mapped fields for all criteria queries" do
+        criteria.attribute_mapping(:artist_name => { :type => :string }).where(:artist_name.ne => nil).to_params[:fq].should == ["artist_name_s:[* TO *]"]
+      end
+      
+      it "uses the column when no mapping defined" do
+        criteria.where(:artist_name => "test").to_params[:fq].should == ["artist_name:test"]
+      end
+    end
+  end
+  
+  describe "#solr_field_from_field" do
+    it "returns the field when no mappings defined" do
+      criteria.solr_field_from_field(:artist_name).should == "artist_name"
+    end
+    
+    it "returns the mapped field when mapping found" do
+      criteria.attribute_mapping(:artist_name => { :type => :string }).solr_field_from_field(:artist_name).should == "artist_name_s"
+    end
   end
 
   describe "#to_a" do
@@ -201,6 +267,17 @@ describe Supernova::SolrCriteria do
       end
     end
     
+    it "returns a Hash when type does not response to " do
+      type = double("type")
+      type.should_receive(:respond_to?).with(:constantize).and_return false
+      criteria.build_doc("type" => type).should be_an_instance_of(Hash)
+    end
+    
+    it "sets the original solr_doc" do
+      solr_doc = { "type" => "Offer", "id" => "offers/id" }
+      criteria.build_doc(solr_doc).instance_variable_get("@solr_doc").should == solr_doc
+    end
+    
     it "should be readonly" do
       criteria.build_doc(docs.first).should be_readonly
     end

data/spec/supernova/solr_indexer_spec.rb

@@ -1,18 +1,27 @@
 require "spec_helper"
 
 describe Supernova::SolrIndexer do
-  
+  let(:indexer_clazz) { Class.new(Supernova::SolrIndexer) }
   let(:db) { double("db", :query => [to_index]) }
   let(:to_index) { { :id => 1, :title => "Some Title"} }
   let(:file_stub) { double("file").as_null_object }
   
-  let(:indexer) {
+  let(:indexer) do
     indexer = Supernova::SolrIndexer.new
     indexer.db = db
     Supernova::Solr.url = "http://solr.xx:9333/solr"
     indexer.stub!(:system).and_return true
     indexer
-  }
+  end
+  
+  let(:custom_indexer) { indexer_clazz.new }
+  
+  before(:each) do
+    indexer_clazz.has(:title, :type => :text)
+    indexer_clazz.has(:artist_id, :type => :integer)
+    indexer_clazz.has(:description, :type => :text)
+    indexer_clazz.has(:created_at, :type => :date)
+  end
   
   before(:each) do
     File.stub!(:open).and_return file_stub
@@ -29,6 +38,82 @@ describe Supernova::SolrIndexer do
       indexer = Supernova::SolrIndexer.new(:db => db)
       indexer.db.should == db
     end
+    
+    it "can be initialized with ids" do
+      Supernova::SolrIndexer.new(:ids => [1, 2]).ids.should == [1, 2]
+    end
+    
+    it "sets ids to all when nil" do
+      Supernova::SolrIndexer.new.ids.should == :all
+    end
+  end
+  
+  describe "index!" do
+    it "calls query_to_index" do
+      indexer.should_receive(:query_to_index).and_return "some query"
+      indexer.index!
+    end
+    
+    it "calls index_query on query_to_index" do
+      query = "some query"
+      indexer.stub!(:query_to_index).and_return query
+      indexer.should_receive(:index_query).with(query)
+      indexer.index!
+    end
+    
+    it "calls row_to_solr with all returned rows from sql" do
+      row1 = double("row1")
+      row2 = double("row2")
+      indexer.stub!(:query).and_return [row1, row2]
+      indexer.stub!(:query_to_index).and_return "some query"
+      indexer.should_receive(:row_to_solr).with(row1)
+      indexer.stub!(:index_query).and_yield(row1)
+      indexer.index!
+    end
+  end
+  
+  describe "validate_lat" do
+    { nil => nil, 10 => 10.0, 90.1 => nil, 90 => 90, -90.1 => nil, -90 => -90 }.each do |from, to|
+      it "converts #{from} to #{to}" do
+        indexer.validate_lat(from).should == to
+      end
+    end
+  end
+  
+  describe "validate_lng" do
+    { nil => nil, 10 => 10.0, 180.1 => nil, 180 => 180, -180.1 => nil, -180 => -180 }.each do |from, to|
+      it "converts #{from} to #{to}" do
+        indexer.validate_lng(from).should == to
+      end
+    end
+  end
+  
+  describe "#sql_column_from_field_and_type" do
+    {
+      [:title, :string] => "title AS title_s",
+      [:count, :int] => "count AS count_i",
+      [:test, :sint] => "test AS test_si",
+      [:lat, :float] => "lat AS lat_f",
+      [:text, :boolean] => "text AS text_b",
+      [:loc, :location] => "loc AS loc_p",
+      [:deleted_at, :date] => %(IF(deleted_at IS NULL, NULL, CONCAT(REPLACE(deleted_at, " ", "T"), "Z")) AS deleted_at_dt),
+    }.each do |(field, type), name|
+      it "maps #{field} with #{type} to #{name}" do
+        indexer.sql_column_from_field_and_type(field, type).should == name
+      end
+    end
+    
+    it "raises an error when no mapping defined" do
+      lambda {
+        indexer.sql_column_from_field_and_type(:text, :rgne)
+      }.should raise_error
+    end
+  end
+  
+  describe "#row_to_solr" do
+    it "returns the db row by default" do
+      indexer.row_to_solr("id" => 1).should == { "id" => 1 }
+    end
   end
   
   describe "#query_db" do
@@ -164,4 +249,193 @@ describe Supernova::SolrIndexer do
       indexer.do_index_file
     end
   end
+
+  describe "define mappings" do
+    let(:blank_indexer_clazz) { Class.new(Supernova::SolrIndexer) }
+    
+    it "has an empty array of field_definitions by default" do
+      blank_indexer_clazz.field_definitions.should == {}
+    end
+    
+    it "has adds filters to the field_definitions" do
+      blank_indexer_clazz.has(:artist_id, :type => :integer, :sortable => true)
+      blank_indexer_clazz.field_definitions.should == { :artist_id => { :type => :integer, :sortable => true } }
+    end
+    
+    it "clazz sets indexed class" do
+      blank_indexer_clazz.clazz(Integer)
+      blank_indexer_clazz.instance_variable_get("@clazz").should == Integer
+    end
+    
+    it "does not change but return the clazz when nil" do
+      blank_indexer_clazz.clazz(Integer)
+      blank_indexer_clazz.clazz.should == Integer
+    end
+    
+    it "allows setting the clazz to nil" do
+      blank_indexer_clazz.clazz(Integer)
+      blank_indexer_clazz.clazz(nil)
+      blank_indexer_clazz.clazz.should be_nil
+    end
+    
+    it "table_name sets the table name" do
+      blank_indexer_clazz.table_name(:people)
+      blank_indexer_clazz.instance_variable_get("@table_name").should == :people
+    end
+    
+    it "table_name does not overwrite but return table_name when nil given" do
+      blank_indexer_clazz.table_name(:people)
+      blank_indexer_clazz.table_name.should == :people
+    end
+    
+    it "allows setting the table_name to nil" do
+      blank_indexer_clazz.table_name(:people)
+      blank_indexer_clazz.table_name(nil).should be_nil
+    end
+  end
+  
+  describe "#default_mappings" do
+    it "returns id when no class defined" do
+      indexer_clazz.new.default_fields.should == ["id"]
+    end
+    
+    it "adds type when class defined" do
+      indexer_clazz.clazz Integer
+      indexer_clazz.new.default_fields.should == ["id", %("Integer" AS type_s)]
+    end
+  end
+  
+  describe "#defined_fields" do
+    let(:field_definitions) { { :title => { :type => :string } } }
+    
+    it "calls field_definitions" do
+      indexer_clazz.should_receive(:field_definitions).and_return field_definitions
+      custom_indexer.defined_fields
+    end
+    
+    ["title AS title_t", "artist_id AS artist_id_i", "description AS description_t", 
+      %(IF(created_at IS NULL, NULL, CONCAT(REPLACE(created_at, " ", "T"), "Z")) AS created_at_dt)
+    ].each do |field|
+      it "includes field #{field.inspect}" do
+        custom_indexer.defined_fields.should include(field)
+      end
+    end
+    
+    it "does not include virtual fields" do
+      clazz = Class.new(Supernova::SolrIndexer)
+      clazz.has :location, :type => :location, :virtual => true
+      clazz.has :title, :type => :string
+      clazz.new.defined_fields.should == ["title AS title_s"]
+    end
+  end
+  
+  describe "#table_name" do
+    it "returns nil when no table_name defined on indexer class and no class defined" do
+      Class.new(Supernova::SolrIndexer).new.table_name.should be_nil
+    end
+    
+    it "returns nil when no table_name defined on indexer class and class does not respond to table name" do
+      clazz = Class.new(Supernova::SolrIndexer)
+      clazz.clazz(Integer)
+      clazz.new.table_name.should be_nil
+    end
+    
+    it "returns the table name defined in indexer class" do
+      clazz = Class.new(Supernova::SolrIndexer)
+      clazz.table_name(:some_table)
+      clazz.new.table_name.should == :some_table
+    end
+    
+    it "returns the table name ob class when responding to table_name" do
+      model_clazz = double("clazz", :table_name => "model_table")
+      clazz = Class.new(Supernova::SolrIndexer)
+      clazz.clazz(model_clazz)
+      clazz.new.table_name.should == "model_table"
+    end
+  end
+
+  describe "#query_to_index" do
+    before(:each) do
+      @indexer_clazz = Class.new(Supernova::SolrIndexer)
+      @indexer_clazz.clazz Integer
+      @indexer_clazz.table_name "integers"
+      @indexer = @indexer_clazz.new
+    end
+    
+    it "raises an error when table_name returns nil" do
+      @indexer_clazz.clazz(nil)
+      @indexer_clazz.table_name(nil)
+      @indexer.should_receive(:table_name).and_return nil
+      lambda {
+        @indexer.query_to_index
+      }.should raise_error("no table_name defined")
+    end
+    
+    it "returns a string" do
+      @indexer.query_to_index.should be_an_instance_of(String)
+    end
+    
+    it "does not include a where when ids is nil" do
+      @indexer.query_to_index.should_not include("WHERE")
+    end
+    
+    it "does include a where when ids are present" do
+      @indexer_clazz.new(:ids => %w(1 2)).query_to_index.should include("WHERE id IN (1, 2)")
+    end
+    
+    it "calls and includes select_fields" do
+      @indexer.should_receive(:select_fields).and_return %w(a c)
+      @indexer.query_to_index.should include("SELECT a, c FROM integers")
+    end
+  end
+  
+  describe "#select_fields" do
+    it "joins default_fields with defined_fields" do
+      default = double("default fields")
+      defined = double("defined fields")
+      indexer.should_receive(:default_fields).and_return [default]
+      indexer.should_receive(:defined_fields).and_return [defined]
+      indexer.select_fields.should == [default, defined]
+    end
+  end
+  
+  describe "#method_missing" do
+    it "returns a new supernova criteria" do
+      indexer_clazz.where(:a => 1).should be_an_instance_of(Supernova::SolrCriteria)
+    end
+    
+    it "sets the correct clazz" do
+      indexer_clazz = Class.new(Supernova::SolrIndexer)
+      indexer_clazz.clazz(String)
+      indexer_clazz.where(:a => 1).clazz.should == String
+    end
+    
+    it "adds the attribute_mapping" do
+      indexer_clazz.where(:a => 1).search_options[:attribute_mapping].should == {
+        :artist_id=>{:type=>:integer}, :title=>{:type=>:text}, :created_at=>{:type=>:date}, :description=>{:type=>:text}
+      }
+    end
+  end
+  
+  describe "#solr_field_for_field_name_and_mapping" do
+    let(:mapping) do 
+      { 
+        :artist_name => { :type => :string },
+        :artist_id => { :type => :integer },
+      }
+    end
+    
+    { 
+      :artist_name => "artist_name_s", "artist_name" => "artist_name_s", 
+      :artist_id => "artist_id_i", :popularity => "popularity" 
+    }.each do |from, to|
+      it "maps #{from} to #{to}" do
+        Supernova::SolrIndexer.solr_field_for_field_name_and_mapping(from, mapping).should == to
+      end
+    end
+    
+    it "returns the original field when mapping is nil" do
+      Supernova::SolrIndexer.solr_field_for_field_name_and_mapping(:artist, nil).should == "artist"
+    end
+  end
 end

data/spec/supernova/symbol_extensions_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe "Supernova::SymbolExtensions" do
+  [:not, :gt, :lt, :gte, :lte, :ne].each do |type|
+    it "returns the correct condition for #{type}" do
+      cond = :user_id.send(type)
+      cond.key.should == :user_id
+      cond.type.should == type
+    end
+  end
+  
+  it "sets the correct key" do
+    :other_id.not.key.should == :other_id
+  end
+end

data/supernova.gemspec

@@ -5,16 +5,17 @@
 
 Gem::Specification.new do |s|
   s.name = %q{supernova}
-  s.version = "0.2.2"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tobias Schwab"]
-  s.date = %q{2011-06-11}
+  s.date = %q{2011-06-12}
   s.description = %q{Unified search scopes}
   s.email = %q{tobias.schwab@dynport.de}
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
+    "README.rdoc",
+    "TODO"
   ]
   s.files = [
     ".autotest",
@@ -29,11 +30,13 @@ Gem::Specification.new do |s|
     "autotest/discover.rb",
     "lib/supernova.rb",
     "lib/supernova/collection.rb",
+    "lib/supernova/condition.rb",
     "lib/supernova/criteria.rb",
     "lib/supernova/numeric_extensions.rb",
     "lib/supernova/solr.rb",
     "lib/supernova/solr_criteria.rb",
     "lib/supernova/solr_indexer.rb",
+    "lib/supernova/symbol_extensions.rb",
     "lib/supernova/thinking_sphinx.rb",
     "lib/supernova/thinking_sphinx_criteria.rb",
     "solr/conf/admin-extra.html",
@@ -77,11 +80,13 @@ Gem::Specification.new do |s|
     "spec/integration/solr_spec.rb",
     "spec/integration/thinking_sphinx_spec.rb",
     "spec/spec_helper.rb",
+    "spec/supernova/condition_spec.rb",
     "spec/supernova/criteria_spec.rb",
     "spec/supernova/numeric_extensions_spec.rb",
     "spec/supernova/solr_criteria_spec.rb",
     "spec/supernova/solr_indexer_spec.rb",
     "spec/supernova/solr_spec.rb",
+    "spec/supernova/symbol_extensions_spec.rb",
     "spec/supernova/thinking_sphinx_criteria_spec.rb",
     "spec/supernova_spec.rb",
     "supernova.gemspec"

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 0
-  - 2
-  - 2
-  version: 0.2.2
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Tobias Schwab
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-11 00:00:00 +02:00
+date: 2011-06-12 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -219,6 +219,7 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE.txt
 - README.rdoc
+- TODO
 files: 
 - .autotest
 - .document
@@ -232,11 +233,13 @@ files:
 - autotest/discover.rb
 - lib/supernova.rb
 - lib/supernova/collection.rb
+- lib/supernova/condition.rb
 - lib/supernova/criteria.rb
 - lib/supernova/numeric_extensions.rb
 - lib/supernova/solr.rb
 - lib/supernova/solr_criteria.rb
 - lib/supernova/solr_indexer.rb
+- lib/supernova/symbol_extensions.rb
 - lib/supernova/thinking_sphinx.rb
 - lib/supernova/thinking_sphinx_criteria.rb
 - solr/conf/admin-extra.html
@@ -280,14 +283,17 @@ files:
 - spec/integration/solr_spec.rb
 - spec/integration/thinking_sphinx_spec.rb
 - spec/spec_helper.rb
+- spec/supernova/condition_spec.rb
 - spec/supernova/criteria_spec.rb
 - spec/supernova/numeric_extensions_spec.rb
 - spec/supernova/solr_criteria_spec.rb
 - spec/supernova/solr_indexer_spec.rb
 - spec/supernova/solr_spec.rb
+- spec/supernova/symbol_extensions_spec.rb
 - spec/supernova/thinking_sphinx_criteria_spec.rb
 - spec/supernova_spec.rb
 - supernova.gemspec
+- TODO
 has_rdoc: true
 homepage: http://github.com/dynport/supernova
 licenses: