supernova 0.3.3 → 0.3.4

data/VERSION

@@ -1 +1 @@
-0.3.3
+0.3.4

data/lib/supernova/solr_criteria.rb

@@ -48,6 +48,15 @@ class Supernova::SolrCriteria < Supernova::Criteria
     Supernova::SolrIndexer.solr_field_for_field_name_and_mapping(field, search_options[:attribute_mapping])
   end
   
+  def reverse_lookup_solr_field(solr_field)
+    if search_options[:attribute_mapping]
+      search_options[:attribute_mapping].each do |field, options|
+        return field if solr_field.to_s == solr_field_from_field(field)
+      end
+    end
+    solr_field
+  end
+  
   def fq_from_with(with)
     if with.blank?
       []
@@ -85,7 +94,7 @@ class Supernova::SolrCriteria < Supernova::Criteria
       if key == "id"
         doc.id = value.to_s.split("/").last if doc.respond_to?(:id=)
       else
-        doc.send(:"#{key}=", value) if doc.respond_to?(:"#{key}=")
+        set_first_responding_attribute(doc, key, value)
       end
     end
     doc.instance_variable_set("@readonly", true)
@@ -93,6 +102,16 @@ class Supernova::SolrCriteria < Supernova::Criteria
     doc
   end
   
+  def set_first_responding_attribute(doc, solr_key, value)
+    [reverse_lookup_solr_field(solr_key), solr_key].each do |key|
+      meth = :"#{key}="
+      if doc.respond_to?(meth)
+        doc.send(meth, value)
+        return
+      end
+    end
+  end
+  
   def to_a
     response = Supernova::Solr.connection.get("select", :params => to_params)
     collection = Supernova::Collection.new(current_page, per_page, response["response"]["numFound"])

data/lib/supernova/solr_indexer.rb

@@ -12,7 +12,7 @@ class Supernova::SolrIndexer
     end
     
     def has(key, attributes)
-      field_definitions[key] = attributes
+      field_definitions[key] = attributes.is_a?(Hash) ? attributes : { :type => attributes }
     end
     
     def clazz(class_name =:only_return)
@@ -190,6 +190,6 @@ class Supernova::SolrIndexer
     else
       %(cd #{File.dirname(index_file_path)} && curl -s '#{solr_url}/update/json?commit=true' --data-binary @#{File.basename(index_file_path)} -H 'Content-type:application/json')
     end
-    system(cmd)
+    Kernel.send(:`, cmd)
   end
 end

data/spec/integration/solr_spec.rb

@@ -10,11 +10,13 @@ describe "Solr" do
     # 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/1", :type => "Offer", :user_id_i => 1, :enabled_b => false, 
+      :text_t => "Hans Meyer", :popularity_i => 10, 
+      :location_p => "#{root.lat},#{root.lng}", :type => "Offer"
     )
-    Supernova::Solr.connection.add(:id => "offers/2", :user_id => 2, :enabled => true, :text => "Marek Mintal", :popularity => 1, 
-      :location => "#{e_lat},#{e_lng}", :type => "Offer"
+    Supernova::Solr.connection.add(:id => "offers/2", :user_id_i => 2, :enabled_b => true, :text_t => "Marek Mintal", 
+      :popularity_i => 1, 
+      :location_p => "#{e_lat},#{e_lng}", :type => "Offer"
     )
     Supernova::Solr.connection.commit
   end
@@ -48,27 +50,27 @@ describe "Solr" do
     
     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]
+        new_criteria.search("text_t:Hans").to_a.map { |h| h["id"] }.should == [1]
+        new_criteria.search("text_t:Hans").search("text_t:Meyer").to_a.map { |h| h["id"] }.should == [1]
+        new_criteria.search("text_t: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 == []
+        new_criteria.search("text_t:Hans", "text_t: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"
+      new_criteria.search("text_t:Hans").to_a.first.instance_variable_get("@solr_doc").should == {
+        "id" => "offers/1", "type" => "Offer", "user_id_i" => 1, "enabled_b" => false, "text_t" => "Hans Meyer", "popularity_i" => 10, 
+        "location_p" => "47,11"
       }
     end
     
     describe "nearby search" do
       { 49.kms => 1, 51.kms => 2 }.each do |distance, total_entries|
         it "returns #{total_entries} for distance #{distance}" do
-          new_criteria.near(47, 11).within(distance).to_a.total_entries.should == total_entries
+          new_criteria.attribute_mapping(:location => { :type => :location }).near(47, 11).within(distance).to_a.total_entries.should == total_entries
         end
       end
     end
@@ -76,54 +78,59 @@ describe "Solr" do
     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
+          new_criteria.with(:user_id_i => 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, 
+        Supernova::Solr.connection.add(:id => "offers/3", :enabled_b => true, :text_t => "Marek Mintal", :popularity_i => 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]
+        new_criteria.with(:user_id_i.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]
+        new_criteria.with(:user_id_i.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
+          new_criteria.with(:user_id_i.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)
+      new_criteria.with(:user_id_i => 1).to_a.first.should be_an_instance_of(Offer)
     end
     
     { :id => 1, :user_id => 1, :enabled => false, :text => "Hans Meyer", :popularity => 10 }.each do |key, value|
       it "sets #{key} to #{value}" do
-        doc = new_criteria.with(:id => "offers/1").to_a.first
+        doc = new_criteria.attribute_mapping(
+          :user_id => { :type => :integer },
+          :enabled => { :type => :boolean },
+          :popularity => { :type => :integer },
+          :text => { :type => :text}
+        ).with(:id => "offers/1").to_a.first
         doc.send(key).should == value
       end
     end
     
     it "combines filters" do
-      new_criteria.with(:user_id => 1, :enabled => false).to_a.total_entries.should == 1
-      new_criteria.with(:user_id => 1, :enabled => true).to_a.total_entries.should == 0
+      new_criteria.with(:user_id_i => 1, :enabled_b => false).to_a.total_entries.should == 1
+      new_criteria.with(:user_id_i => 1, :enabled_b => true).to_a.total_entries.should == 0
     end
     
     it "uses without correctly" do
-      new_criteria.without(:user_id => 1).to_a.map(&:id).should == [2]
-      new_criteria.without(:user_id => 2).to_a.map(&:id).should == [1]
-      new_criteria.without(:user_id => 2).without(:user_id => 1).to_a.map(&:id).should == []
+      new_criteria.without(:user_id_i => 1).to_a.map(&:id).should == [2]
+      new_criteria.without(:user_id_i => 2).to_a.map(&:id).should == [1]
+      new_criteria.without(:user_id_i => 2).without(:user_id_i => 1).to_a.map(&:id).should == []
     end
     
     it "uses the correct orders" do
@@ -132,25 +139,25 @@ describe "Solr" do
     end
     
     it "uses the correct pagination attributes" do
-      new_criteria.with(:user_id => 1, :enabled => false).to_a.total_entries.should == 1
-      new_criteria.with(:user_id => 1, :enabled => false).length.should == 1
-      new_criteria.with(:user_id => 1, :enabled => false).paginate(:page => 10).to_a.total_entries.should == 1
-      new_criteria.with(:user_id => 1, :enabled => false).paginate(:page => 10).length.should == 0
+      new_criteria.with(:user_id_i => 1, :enabled_b => false).to_a.total_entries.should == 1
+      new_criteria.with(:user_id_i => 1, :enabled_b => false).length.should == 1
+      new_criteria.with(:user_id_i => 1, :enabled_b => false).paginate(:page => 10).to_a.total_entries.should == 1
+      new_criteria.with(:user_id_i => 1, :enabled_b => false).paginate(:page => 10).length.should == 0
       
       new_criteria.paginate(:per_page => 1, :page => 1).to_a.map(&:id).should == [1]
       new_criteria.paginate(:per_page => 1, :page => 2).to_a.map(&:id).should == [2]
     end
     
     it "handels empty results correctly" do
-      results = new_criteria.with(:user_id => 1, :enabled => true).to_a
+      results = new_criteria.with(:user_id_i => 1, :enabled_b => true).to_a
       results.total_entries.should == 0
       results.current_page.should == 1
     end
     
     it "only sets specific attributes" do
-      results = new_criteria.select(:user_id).with(:user_id => 1).to_a
+      results = new_criteria.select(:user_id_i).with(:user_id_i => 1).to_a
       results.length.should == 1
-      results.first.should == { "id" => "offers/1", "user_id" => 1 }
+      results.first.should == { "id" => "offers/1", "user_id_i" => 1 }
     end
   end
 end

data/spec/supernova/solr_criteria_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require "ostruct"
 
 describe Supernova::SolrCriteria do
   let(:criteria) { Supernova::SolrCriteria.new }
@@ -286,6 +287,13 @@ describe Supernova::SolrCriteria do
       criteria.build_doc(docs.first).should_not be_a_new_record
     end
     
+    it "uses attribute_mapping when defined" do
+      criteria.attribute_mapping(:enabled => { :type => :boolean }, :popularity => { :type => :integer })
+      doc = criteria.build_doc("type" => "Offer", "id" => "offers/1", "enabled_b" => true, "popularity_i" => 10)
+      doc.should be_an_instance_of(Offer)
+      doc.popularity.should == 10
+    end
+    
     class MongoOffer
       attr_accessor :id
     end
@@ -301,6 +309,35 @@ describe Supernova::SolrCriteria do
     end
   end
   
+  describe "#reverse_lookup_solr_field" do
+    it "returns the key when no mapping found" do
+      Supernova::SolrCriteria.new.reverse_lookup_solr_field(:artist_id_s).should == :artist_id_s
+    end
+    
+    it "returns the correct original key when mapped" do
+      criteria.attribute_mapping(:artist_name => { :type => :string }).reverse_lookup_solr_field(:artist_name_s).should == :artist_name
+    end
+  end
+  
+  describe "#set_first_responding_attribute" do
+    it "sets the reverse looked up attribute when found" do
+      doc = OpenStruct.new(:artist_name => nil)
+      criteria.attribute_mapping(:artist_name => { :type => :string }).set_first_responding_attribute(doc, :artist_name_s, "Mos Def")
+      doc.artist_name.should == "Mos Def"
+    end
+    
+    it "sets the original key when no mapping defined" do
+      doc = OpenStruct.new(:artist_name_s => nil)
+      criteria.attribute_mapping(:artist_name => { :type => :string }).set_first_responding_attribute(doc, :artist_name_s, "Mos Def")
+      doc.artist_name_s.should == "Mos Def"
+    end
+    
+    it "does not break on unknown keys" do
+      doc = double("dummy")
+      criteria.attribute_mapping(:artist_name => { :type => :string }).set_first_responding_attribute(doc, :artist_name_s, "Mos Def")
+    end
+  end
+  
   describe "#current_page" do
     it "returns 1 when pagiantion is not set" do
       criteria.current_page.should == 1

data/spec/supernova/solr_indexer_spec.rb

@@ -25,6 +25,7 @@ describe Supernova::SolrIndexer do
   
   before(:each) do
     File.stub!(:open).and_return file_stub
+    Kernel.stub!(:`).and_return true
   end
   
   describe "initialize" do
@@ -238,14 +239,14 @@ describe Supernova::SolrIndexer do
     
     it "calls the correct curl command" do
       indexer.index_file_path = "/tmp/some_path.json"
-      indexer.should_receive(:system).with("curl -s 'http://solr.xx:9333/solr/update/json?commit=true\\&stream.file=/tmp/some_path.json'")
+      Kernel.should_receive(:`).with("curl -s 'http://solr.xx:9333/solr/update/json?commit=true\\&stream.file=/tmp/some_path.json'")
       indexer.do_index_file(:local => true)
     end
     
     it "executes the correct curl call when not local" do
       # curl 'http://localhost:8983/solr/update/json?commit=true' --data-binary @books.json -H 'Content-type:application/json'
       indexer.index_file_path = "/tmp/some_path.json"
-      indexer.should_receive(:system).with("cd /tmp && curl -s 'http://solr.xx:9333/solr/update/json?commit=true' --data-binary @some_path.json -H 'Content-type:application/json'")
+      Kernel.should_receive(:`).with("cd /tmp && curl -s 'http://solr.xx:9333/solr/update/json?commit=true' --data-binary @some_path.json -H 'Content-type:application/json'")
       indexer.do_index_file
     end
   end
@@ -262,6 +263,11 @@ describe Supernova::SolrIndexer do
       blank_indexer_clazz.field_definitions.should == { :artist_id => { :type => :integer, :sortable => true } }
     end
     
+    it "has can also be called with a symbol as argument and sets that to the type" do
+      blank_indexer_clazz.has(:artist_id, :integer)
+      blank_indexer_clazz.field_definitions.should == { :artist_id => { :type => :integer } }
+    end
+    
     it "clazz sets indexed class" do
       blank_indexer_clazz.clazz(Integer)
       blank_indexer_clazz.instance_variable_get("@clazz").should == Integer

data/supernova.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{supernova}
-  s.version = "0.3.3"
+  s.version = "0.3.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tobias Schwab"]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: supernova
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 27
   prerelease: 
   segments: 
   - 0
   - 3
-  - 3
-  version: 0.3.3
+  - 4
+  version: 0.3.4
 platform: ruby
 authors: 
 - Tobias Schwab