smart_search 0.0.65 → 0.0.67

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 09683d827340bc1dc832274e31723252da084649
-  data.tar.gz: 580b05753d0355b99502205b99276bf71eb6bf58
+  metadata.gz: ea2edfd305ac9960e74f36148bc8710e0b877416
+  data.tar.gz: 0d7d5bd0c94c3624d11d83fded3abcd6cb1a42a3
 SHA512:
-  metadata.gz: 54a44b78402531aa5098329681e7929f3f97671e42cd5bbe5b517e5143bfa4b9e671179a3d99b537fe8c43de770929ee3c7041be4d2f28197be242bedb774333
-  data.tar.gz: 89df4b626f3f3979a509f637aa5112c6452cf1394108223ba80f603d36534d24331e5864d0ca1d6f85539cf6430cf291a4fdaf385b92bfef6ec17c9358b21fa2
+  metadata.gz: 2b5192daa702b12f37fbd75dda8a077815ffd63974e9f8fd0c4a95c29adfa35f942e413c677f7c9d6e631c20cc5e617716b1267c3d5a06fde21c1dcc37cfc9e9
+  data.tar.gz: 94667a98ba392b0e0dafe5339f425e27cc4d0d5fbbd75450e815a0271a25a700e6c3c9d282b896bf49033bad72d34c0bb3053c9729ab0e8adf7782caeb5001a1

data/lib/smart_search.rb

@@ -15,6 +15,7 @@ module SmartSearch
     base.extend ClassMethods
   end  
   
+  # Class Methods for ActiveRecord
   module ClassMethods
     # Enable SmartSearch for the current ActiveRecord model.
     # accepts options:
@@ -26,14 +27,16 @@ module SmartSearch
     def smart_search(options = {:on => [], :conditions => nil, :group => nil, :order => "created_at", :force => false})
       if table_exists?
         # Check if search_tags exists
-        if !is_smart_search? || options[:force] == true
+        if !is_smart_search? || options[:force] == true || Rails.env == "test"
           
-          cattr_accessor :condition_default, :group_default, :tags, :order_default, :enable_similarity
+          cattr_accessor :condition_default, :group_default, :tags, :order_default, :enable_similarity, :default_template_path
           send :include, InstanceMethods
             self.send(:after_save, :create_search_tags)
             self.send(:before_destroy, :create_search_tags)
             self.enable_similarity ||= true
             
+            attr_accessor :query_score
+            
             # options zuweisen
             if options[:conditions].is_a?(String) && !options[:conditions].blank?
               self.condition_default = options[:conditions]
@@ -43,11 +46,7 @@ module SmartSearch
               self.condition_default = nil
             end  
           
-            if self.column_names.include?("created_at")
-              self.order_default = options[:order] || "created_at"
-            else  
-              self.order_default = options[:order] || "id"
-            end  
+            self.order_default = options[:order]
 
             self.tags = options[:on] || []
         end
@@ -73,7 +72,7 @@ module SmartSearch
           self.connection.execute("INSERT INTO `#{::SmartSearchHistory.table_name}` (`query`) VALUES ('#{tags.gsub(/[^a-zA-ZäöüÖÄÜß\ ]/, '')}');")
         end  
         
-        tags = tags.split(" ")
+        tags = tags.split(/[\ -]/).select {|t| !t.blank?}
         
         # Fallback for Empty String
         tags << "#" if tags.empty?
@@ -90,12 +89,24 @@ module SmartSearch
         end  
         
         # Load ranking from Search tags
-        result_ids = SmartSearchTag.connection.select_all("select entry_id, sum(boost), group_concat(search_tags) as grouped_tags 
+        result_ids = []
+        result_scores = {}
+          SmartSearchTag.connection.select_all("select entry_id, sum(boost) as score, group_concat(search_tags) as grouped_tags 
         from smart_search_tags where `table_name`= '#{self.table_name}' and 
         
-        (#{tags.join(' OR ')}) group by entry_id having (#{tags.join(' AND ').gsub('search_tags', 'grouped_tags')}) order by sum(boost) DESC").map {|r| r["entry_id"]}
+        (#{tags.join(' OR ')}) group by entry_id having (#{tags.join(' AND ').gsub('search_tags', 'grouped_tags')}) order by score DESC").each do |r| 
+          result_ids << r["entry_id"].to_i 
+          result_scores[r["entry_id"].to_i] = r['score'].to_f
+        end  
+        
+        # Enable unscoped searching
+        if options[:unscoped] == true
+          results     =  self.unscoped.where(:id => result_ids)
+        else  
+          results     =  self.where(:id => result_ids)
+        end  
+        
         
-        results =  self.where(:id => result_ids)
         
         if options[:conditions]
           results = results.where(options[:conditions])
@@ -105,15 +116,21 @@ module SmartSearch
           results = results.where(self.condition_default)
         end  
         
-        if options[:group]
+        if options[:group] 
           results = results.group(options[:group])
         end  
         
-        if options[:order]
-          results = results.order(options[:order])
+        if options[:order] || self.order_default
+          results = results.order(options[:order] || self.order_default)
         else
-          results = results.order(self.order_default)
-        end    
+          ordered_results = []
+          results.each do |r| 
+            r.query_score = result_scores[r.id]
+            ordered_results[result_ids.index(r.id)] = r
+          end  
+          
+          results = ordered_results.compact
+        end      
                 
         return results
       else                      
@@ -125,7 +142,7 @@ module SmartSearch
     def set_search_index
       s = self.all.size.to_f
       self.all.each_with_index do |a, i|
-        a.create_search_tags rescue nil
+        a.create_search_tags
         a.send(:update_without_callbacks)
         done = ((i+1).to_f/s)*100
         printf "Set search index for #{self.name}: #{done}%%                  \r"
@@ -142,8 +159,10 @@ module SmartSearch
          
   end  
   
+  # Instance Methods for ActiveRecord
   module InstanceMethods
     
+    # Load the result template path for this instance
     def result_template_path
       self.class.result_template_path
     end  
@@ -178,14 +197,25 @@ module SmartSearch
       
       
       self.clear_search_tags
-        
+      
+      # Merge search tags with same boost
+      #merged_tags = {}
+      #tags.each do |t|
+      #  if merged_tags[t[:boost]]
+      #    merged_tags[t[:boost]][:field_name] << ",#{t[:field_name].to_s}"
+      #    merged_tags[t[:boost]][:search_tags] << " #{t[:search_tags]}"
+      #  else
+      #    merged_tags[t[:boost]] = {:field_name => t[:field_name].to_s, :search_tags => t[:search_tags], :boost => t[:boost] }
+      #  end    
+      #end  
+      
       tags.each do |t|
         SmartSearchTag.create(t.merge!(:table_name => self.class.table_name, :entry_id => self.id))
       end
-   
       
     end
     
+    # Remove search data for the instance from the index
     def clear_search_tags
       if !self.id.nil?
         SmartSearchTag.connection.execute("DELETE from #{SmartSearchTag.table_name} where `table_name` = '#{self.class.table_name}' and entry_id = #{self.id}")

data/lib/smart_search/smart_search_engine.rb

@@ -1,5 +1,7 @@
+# :nodoc:
 module SmartSearch
   require "rails"
+  # :nodoc:
   class SmartSearchEngine < Rails::Engine
     isolate_namespace SmartSearch
     require "friendly_extensions"

data/lib/smart_search_ignore_word.rb

@@ -1,3 +1,5 @@
+# The keep words out of the index, they can be added into this table
+# TODO: Its not working yet
 class SmartSearchIgnoreWord < ActiveRecord::Base
 
   #= Configuration

data/lib/smart_search_tag.rb

@@ -1,2 +1,3 @@
+# Represents the search index
 class SmartSearchTag < ActiveRecord::Base
 end  

data/lib/smart_similarity.rb

@@ -16,7 +16,7 @@ class SmartSimilarity < ActiveRecord::Base
 
       #== Konstanten
           # Defines the min. result of word simililarity check
-          SIMILARITY_FACTOR = 0.8
+          SIMILARITY_FACTOR = 0.77
           # Defines first simililarity check method 
           SIMILARITY_METHOD_1 = :jarowinkler
           # Defines first simililarity check method 
@@ -24,9 +24,10 @@ class SmartSimilarity < ActiveRecord::Base
           
           # An average of both results will generated and compered with 'SIMILARITY_FACTOR'
           
-          # Limit Number of similar words
+          # Limit Number of similar words (still unused)
           SIMILARITY_LIMIT  = 8
           
+          # USe this regexp to split texts into words
           SPLITTING_REGEXP = /\b/
           
       #== Validation and Callbacks
@@ -52,8 +53,12 @@ class SmartSimilarity < ActiveRecord::Base
         else  
           current = words_in_db.similarities
         end  
-        
-        current += prepared_text.select {|w| w != word && self.match_words(w,word) >= SIMILARITY_FACTOR}
+          
+        # If word is a substring of similarity word, it must not be saved,
+        # cause it will match anyway:
+        # 'how' will match 'show', so 'show' is not needed in index for 'how'
+        # Vice Versa, 'how' should also be found if query is 'show', so it will be kept in the index
+        current += prepared_text.select {|w| w != word && self.match_words(w,word) >= SIMILARITY_FACTOR && !w.match(word)}
         
         list[word] = current.uniq
       end  
@@ -101,8 +106,9 @@ class SmartSimilarity < ActiveRecord::Base
     
     # Loads your created query history and saves them to the index
     def self.load_from_query_history
-      queries = ActiveRecord::Base.connection.select_all("SELECT query from `#{::SmartSearchHistory.table_name}`").map {|r| r["query"]}.join(" ")
-      self.create_from_text(queries)
+      queries = ActiveRecord::Base.connection.select_all("SELECT query from `#{::SmartSearchHistory.table_name}`").map {|r| r["query"]}
+      queries.each {|q| self.add_word(q) }
+      
       self.connection.execute("TRUNCATE `#{::SmartSearchHistory.table_name}`")
     end
     

data/test/unit/01_smart_search_test.rb

@@ -61,15 +61,21 @@ class SmartSearchTest < Test::Unit::TestCase
     
     assert_equal  user_c, User.find_by_tags("test", :order => :last_name).first
     assert_equal  user_a, User.find_by_tags("test", :order => :last_name).last
-  end   
+  end
   
-  def test_result_should_be_redefinable
-    user_c    = User.create(:first_name => "C", :last_name => "Next1")
-    user_a    = User.create(:first_name => "A", :last_name => "Bah")
-    user_b    = User.create(:first_name => "B", :last_name => "Next2")
+  def test_search_tags_should_work_with_array_of_strings   
+    User.smart_search :on => %w(first_name last_name office.name), :force => true
+    o = Office.create(:name => "Neandertal")
+    u = User.create(:first_name => "Homo", :last_name => "Sapiens", :office_id => o.id)
     
-    assert_equal [],  User.find_by_tags("A").where("last_name <> 'Bah' ")
-  end 
+  end  
+  
+  
+  def test_should_create_search_history
+    User.find_by_tags("XXXYYY")
+
+    assert_not_equal 0, SmartSearchHistory.where(:query => "XXXYYY").size
+  end  
   
   
 end  

data/test/unit/03_smart_search_boost_test.rb

@@ -0,0 +1,60 @@
+# -*- encoding : utf-8 -*-
+require "test_helper"
+class SmartSearchBoostTest < Test::Unit::TestCase
+
+  def test_boost_search_index_cols_should_be_created
+    SmartSearchTag.connection.execute("TRUNCATE #{SmartSearchTag.table_name}")
+    Customer.smart_search :on => [
+      {:field_name => :first_name, :boost => 1},
+      {:field_name => :last_name, :boost => 2},
+      {:field_name => "user.full_name", :boost => 0.5},
+      ], :force => true
+    
+    user = User.create(:first_name => "Pi", :last_name => "Pa")
+    
+    Customer.create(:first_name => "Lorem", :last_name => "Ipsum", :user_id => user.id)
+    
+    assert_equal 1, SmartSearchTag.where(:field_name => "first_name", :boost => 1).count
+    assert_equal 1, SmartSearchTag.where(:field_name => "last_name", :boost => 2).count
+    assert_equal 1, SmartSearchTag.where(:field_name => "user.full_name", :boost => 0.5).count
+  end
+  
+  def test_boost_search__results_should_order_by_score
+    Customer.smart_search :on => [
+      {:field_name => :first_name, :boost => 1},
+      {:field_name => :last_name, :boost => 2},
+      {:field_name => "user.full_name", :boost => 0.5},
+      ], :force => true
+    
+    user = User.create(:first_name => "Rudi", :last_name => "Piff")
+    
+    c1 = Customer.create(:first_name => "Rudi", :last_name => "Rolle", :user_id => user.id)
+    c2 = Customer.create(:first_name => "Rolle", :last_name => "Rudi", :user_id => user.id)
+    c3 = Customer.create(:first_name => "Jackie", :last_name => "Brown", :user_id => user.id)
+    
+    results = Customer.find_by_tags("Rudi")
+    
+    assert_equal c1, results[1]
+    assert_equal c2, results[0]
+    assert_equal c3, results[2]
+  end
+  
+  
+  def test_same_boost_search_index_cols_should_be_grouped
+    
+    Customer.smart_search :on => [
+      {:field_name => :first_name, :boost => 2},
+      {:field_name => :last_name, :boost => 2},
+      {:field_name => "user.full_name", :boost => 0.5},
+      ], :force => true
+    
+    user = User.create(:first_name => "Pipi", :last_name => "Papa")
+    
+    customer = Customer.create(:first_name => "Lorem", :last_name => "Ipsum", :user_id => user.id)
+    
+    assert_equal 2, SmartSearchTag.where(:table_name => Customer.table_name, :entry_id => customer.id).count
+  end
+ 
+  
+  
+end  

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: smart_search
 version: !ruby/object:Gem::Version
-  version: 0.0.65
+  version: 0.0.67
 platform: ruby
 authors:
 - Florian Eck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-16 00:00:00.000000000 Z
+date: 2014-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.2.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.2.9
 - !ruby/object:Gem::Dependency
@@ -66,8 +66,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: SmartSearch adds full-text search functions to ActiveRecord, including
-  search for similiar words. Its fast, simple, and works with almost zero-config!
+description: SmartSearch adds full-text search functions to ActiveRecord running with
+  MySQL, including search for similiar words. Its fast, simple, and works with almost
+  zero-config!
 email: it-support@friends-systems.de
 executables: []
 extensions: []
@@ -88,7 +89,8 @@ files:
 - test/test_helper.rb
 - test/unit/01_smart_search_test.rb
 - test/unit/02_smart_search_similarity_test.rb
-homepage: https://rubygems.org/gems/smart_search
+- test/unit/03_smart_search_boost_test.rb
+homepage: https://github.com/florianeck/smart_search
 licenses: []
 metadata: {}
 post_install_message: 
@@ -117,3 +119,5 @@ test_files:
 - test/test_helper.rb
 - test/unit/01_smart_search_test.rb
 - test/unit/02_smart_search_similarity_test.rb
+- test/unit/03_smart_search_boost_test.rb
+has_rdoc: