smart_search 0.0.9 → 0.0.55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c08e3ef5c746dc3f5b7c2f0a7d701f300959c3e2
-  data.tar.gz: 568bda297c771f7463564c08a45e9d0100394dd9
+  metadata.gz: ebbed44ee232de1e1b002de0114c895f22669cbe
+  data.tar.gz: 6fe910045758f11f1c1fccc40229ca3b14919361
 SHA512:
-  metadata.gz: 14bf84d39e24dfe58175ff354bf2ddf5600e26ba60be773fcdaf7a88f796f11e3e5beb431b6cb65f943d62d2ced70438eadf3b981f62c6e3771a9e774a2593a5
-  data.tar.gz: 95941557d79b6979a41c5df85d675da72a09bb54036708a321a97b4e4c2b1b8558ae038db04b7455ced7456fdff86094b4d11bed5af9514a21e22361ba78a535
+  metadata.gz: 92f42ecd8d1f22b42221f93453ff31df341d546771525183c8fef42cd900aa05db1148c3251832e75e28e4f38170916b9aee4bef9862bc8d72b06959f89a17eb
+  data.tar.gz: b1d4e94ec2556002bce8a453d6830eae3eb6808f1af30580e988bf5ccb785ff4eee7014d6ad7951a3eae5b9d0a22e5b64eb72ad9763f6185c7c73fa00ed46495

data/lib/add_search_tags.rb

@@ -0,0 +1,8 @@
+# -*- encoding : utf-8 -*-
+class AddSearchTags < ActiveRecord::Migration
+ 
+  def self.add_to_table(table_name)
+    add_column table_name, :search_tags, :text
+  end  
+  
+end

data/lib/smart_search.rb

@@ -1,261 +1,151 @@
 # -*- encoding : utf-8 -*-
-require "rails"
-
 require "smart_search"
-require "smart_search/engine"
-
-require "smart_similarity"
-require "smart_search_history"
-require "smart_search_tag"
-
+require "add_search_tags"
 
 module SmartSearch
-
+  
   def self.included(base)
     base.extend ClassMethods
-  end
-
-  # Class Methods for ActiveRecord
+  end  
+  
   module ClassMethods
-    # Enable SmartSearch for the current ActiveRecord model.
-    # accepts options:
-    # - :on, define which attributes to add to the search index
-    # - :conditions, define default scope for all queries made
-    # - :group, group by column
-    # - :order, order by column
-    # see readme for details
     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 || Rails.env == "test"
-
-          cattr_accessor :condition_default, :group_default, :tags, :order_default, :enable_similarity, :default_template_path
+        if !is_smart_search? || options[:force] == true
+          puts "\nAdding SmartSearch to #{self.name}: #{options.inspect}"
+          cattr_accessor :condition_default, :group_default, :tags, :order_default
           send :include, InstanceMethods
-            self.send(:after_save, :create_search_tags, :if => :update_search_tags?) unless options[:auto] == false
-            self.send(:before_destroy, :clear_search_tags)
-            self.enable_similarity ||= true
-
-            attr_accessor :query_score, :dont_update_search_tags
+          if self.column_names.index("search_tags").nil?
+            ::AddSearchTags.add_to_table(self.table_name)
+          end
+            self.send(:before_save, :create_search_tags)
 
             # options zuweisen
             if options[:conditions].is_a?(String) && !options[:conditions].blank?
               self.condition_default = options[:conditions]
             elsif !options[:conditions].nil?
-              raise ArgumentError, ":conditions must be a valid SQL Query"
+              raise ArgumentError, ":conditions must be a valid SQL Query"  
             else
               self.condition_default = nil
-            end
-
-            self.order_default = options[:order]
+            end  
+          
+            if self.column_names.include?("created_at")
+              self.order_default = options[:order] || "created_at"
+            else  
+              self.order_default = options[:order] || "id"
+            end  
 
             self.tags = options[:on] || []
         end
-      end
+      end  
     end
-
-    # Verify if SmartSearch already loaded for this model
+    
     def is_smart_search?
       self.included_modules.include?(InstanceMethods)
     end
-
-    # defines where to look for a partial to load when displaying results for this model
+    
     def result_template_path
       "/search/results/#{self.name.split("::").last.underscore}"
-    end
-
-    # Serach database for given search tags
+    end  
+    
     def find_by_tags(tags = "", options = {})
       if self.is_smart_search?
-
-        tags = tags.join(" ") if tags.is_a?(Array)
-
-        # Save Data for similarity analysis
-        if tags.size > 3
-          self.connection.execute("INSERT INTO `#{::SmartSearchHistory.table_name}` (`query`) VALUES ('#{tags.gsub(/[^a-zA-ZäöüÖÄÜß\ ]/, '')}');")
-        end
-
-        tags = tags.gsub(/[\(\)\[\]\'\"\*\%\|]/, '').split(/[\ -]/).select {|t| !t.blank?}
-
+        tags = tags.split(" ")
+        
         # Fallback for Empty String
         tags << "#" if tags.empty?
-
-        # Similarity
-        if self.enable_similarity == true
-          tags.map! do |t|
-            similars = SmartSimilarity.similars(t, :increment_counter => true).join("|")
-            "search_tags REGEXP '#{similars}'"
-          end
-
-        else
-          tags.map! {|t| "search_tags LIKE '%#{t}%'"}
-        end
-
-        # Load ranking from Search 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 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
-
+        
+        tags.map! {|t| "search_tags LIKE '%#{t.downcase}%'"}
+        
+        
+        results =  self.where("(#{tags.join(' AND ')})")
+        
         if options[:conditions]
           results = results.where(options[:conditions])
         end
-
+        
         if !self.condition_default.blank?
           results = results.where(self.condition_default)
-        end
-
+        end  
+        
         if options[:group]
           results = results.group(options[:group])
-        end
-
-        if options[:order] || self.order_default
-          results = results.order(options[:order] || self.order_default)
+        end  
+        
+        if options[:order]
+          results = results.order(options[:order])
         else
-          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
-
+          results = results.order(self.order_default)
+        end    
+                
         return results
-      else
+      else                      
         raise "#{self.inspect} is not a SmartSearch"
-      end
+      end  
     end
-
-    # reload search_tags for entire table based on the attributes defined in ':on' option passed to the 'smart_search' method
+    
     def set_search_index
       s = self.all.size.to_f
       self.all.each_with_index do |a, i|
         a.create_search_tags
+        a.send(:update_without_callbacks)
         done = ((i+1).to_f/s)*100
-      end
-    end
-
-    # Load all search tags for this table into similarity index
-    def set_similarity_index
-      search_tags_list = self.connection.select_all("SELECT search_tags from #{SmartSearchTag.table_name} where `table_name` = #{self.table_name}").map {|r| r["search_tags"]}
-
-      SmartSimilarity.create_from_text(search_tags_list.join(" "))
-    end
-
-  end
-
-  # Instance Methods for ActiveRecord
+        printf "Set search index for #{self.name}: #{done}%%                  \r"
+      end  
+    end  
+         
+  end  
+  
   module InstanceMethods
-
-    # Load the result template path for this instance
+    
     def result_template_path
       self.class.result_template_path
-    end
-
-    def dont_update_search_tags!
-      self.dont_update_search_tags = true
-    end
-
-    def update_search_tags?
-      !self.dont_update_search_tags
-    end
-
-    # create search tags for this very record based on the attributes defined in ':on' option passed to the 'Class.smart_search' method
+    end  
+    
     def create_search_tags
-      tags      = []
-
+      tags = []
       self.class.tags.each do |tag|
-
-        if !tag.is_a?(Hash)
-          tag = {:field_name => tag, :boost => 1, :search_tags => ""}
-        else
-          tag[:search_tags] = ""
-          tag[:boost] ||= 1
-        end
-
-        if tag[:field_name].is_a?(Symbol)
-          tag[:search_tags] << self.send(tag[:field_name]).to_s
-        elsif tag[:field_name].is_a?(String)
-          tag_methods = tag[:field_name].split(".")
+        if tag.is_a?(Symbol)
+          tags << self.send(tag)
+        elsif tag.is_a?(String)
+          tag_methods = tag.split(".")  
           tagx = self.send(tag_methods[0])
           tag_methods[1..-1].each do |x|
             tagx = tagx.send(x) rescue ""
           end
-          tag[:search_tags] << tagx.to_s
-        end
-
-        tag[:search_tags] = tag[:search_tags].split(" ").uniq.join(" ").downcase.clear_html
-        tags << tag
-      end
-
-
-      self.clear_search_tags
-
-      # Merge search tags with same boost
-      @merged_tags = {}
-
-      tags.each do |t|
-        boost = t[:boost]
-
-        if @merged_tags[boost]
-
-          @merged_tags[boost][:field_name] << ",#{t[:field_name]}"
-          @merged_tags[boost][:search_tags] << " #{t[:search_tags]}"
-        else
-          @merged_tags[boost] = {:field_name => "#{t[:field_name]}", :search_tags => t[:search_tags], :boost => boost }
-        end
-
-      end
-
-      @merged_tags.values.each do |t|
-        if !t[:search_tags].blank? && t[:search_tags].size > 1
-          SmartSearchTag.create(t.merge!(:table_name => self.class.table_name, :entry_id => self.id, :search_tags => t[:search_tags].strip.split(" ").uniq.join(" ")))
-        end
-      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}") rescue nil
+          tags << tagx  
+        end  
       end
-    end
-
-  end
-
-
+      searchtags = tags.join(" ").split(" ")  
+      searchtags = searchtags.uniq.join(" ")
+      search_tags_min = searchtags.gsub(" ", "").downcase
+      
+      self.search_tags = "#{searchtags.downcase}"
+    end  
+    
+  end    
+        
+  
   class Config
-
+    
     cattr_accessor  :search_models
     cattr_accessor  :public_models
-
+    
     self.search_models = []
     self.public_models = []
-
+    
     def self.get_search_models
-      self.search_models.map {|m| m.constantize}
+      self.search_models.map {|m| m.constantize}  
     end
-
+    
     def self.get_public_models
-      self.public_models.map {|m| m.constantize}
-    end
-
-  end
-
-
+      self.public_models.map {|m| m.constantize}  
+    end  
+    
+  end  
+  
+  
 end
 
 

data/test/test_helper.rb

@@ -1,16 +1,14 @@
 # -*- encoding : utf-8 -*-
 require 'rubygems'
-require 'bundler'
 require 'test/unit'
 require 'active_support'
 require 'active_record'
 require 'active_model'
 
 require "smart_search"
-require "smart_search/smart_search_engine"
+require "add_search_tags"
 
-
-ActiveRecord::Base.establish_connection(:adapter => "mysql2", :database => "smart_search_test")
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
 
   ActiveRecord::Schema.define(:version => 1) do
     create_table :users do |t|
@@ -18,6 +16,7 @@ ActiveRecord::Base.establish_connection(:adapter => "mysql2", :database => "smar
       t.string  :last_name
       t.integer :office_id
       t.date    :birthday
+      t.text    :search_tags
       t.timestamps
     end
     
@@ -26,15 +25,15 @@ ActiveRecord::Base.establish_connection(:adapter => "mysql2", :database => "smar
       t.string  :last_name
       t.integer :user_id
       t.date    :birthday
+      t.text    :search_tags
       t.timestamps
     end
     
     create_table  :offices do |t|  
       t.string  :name
+      t.text    :search_tags
       t.timestamps
-    end
-    
-      
+    end  
   end  
 # 
 # def drop_db

data/test/unit/{01_smart_search_test.rb → smart_search_test.rb}

@@ -6,8 +6,6 @@ class SmartSearchTest < Test::Unit::TestCase
     office_name = "Office1"
     office = Office.create(:name => office_name)
     
-    Office.enable_similarity = false
-    
     assert_equal office, Office.find_by_tags(office_name).first
   end
   
@@ -38,7 +36,6 @@ class SmartSearchTest < Test::Unit::TestCase
     office_id_nok = 5
     
     User.smart_search :on => [:full_name], :conditions => "office_id <> #{office_id_nok}", :force => true
-    User.enable_similarity = false
     
     user    = User.create(:first_name => "Unknown", :last_name => "User", :office_id => office_id_nok)
     user    = User.create(:first_name => "Public", :last_name => "User", :office_id => office_id_ok)
@@ -49,7 +46,6 @@ class SmartSearchTest < Test::Unit::TestCase
   
   def test_should_use_default_order_and_order_should_be_overwriteable
     User.smart_search :on => [:full_name], :order => :first_name, :force => true
-    User.enable_similarity = false
     
     user_c    = User.create(:first_name => "C", :last_name => "Test1")
     user_a    = User.create(:first_name => "A", :last_name => "Test3")
@@ -61,21 +57,17 @@ 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_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)
+  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")
     
+    assert_equal [],  User.find_by_tags("A").where("last_name <> 'Bah' ")
   end  
   
   
-  def test_should_create_search_history
-    User.find_by_tags("XXXYYY")
-
-    assert_not_equal 0, SmartSearchHistory.where(:query => "XXXYYY").size
-  end  
   
   
 end  

metadata

@@ -1,95 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: smart_search
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.55
 platform: ruby
 authors:
 - Florian Eck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-25 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rails
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.0.4
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.0.4
-- !ruby/object:Gem::Dependency
-  name: amatch
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: friendly_extensions
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: mysql2
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-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: florian.eck@el-digital.de
+date: 2013-03-11 00:00:00.000000000 Z
+dependencies: []
+description: Adds easy to use full-text search to ActiveRecord models, based the attributes
+  you want to search.
+email: it-support@friends-systems.de
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- config/database.yml
 - config/routes.rb
+- lib/add_search_tags.rb
 - lib/smart_search.rb
-- lib/smart_search/engine.rb
-- lib/smart_search_history.rb
-- lib/smart_search_tag.rb
-- lib/smart_similarity.rb
-- lib/tasks/smart_search.rake
-- lib/tasks/testing.rake
-- test/test_document_multi_line.txt
-- test/test_document_one_line.txt
 - 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
-homepage: https://github.com/florianeck/smart_search
+- test/unit/smart_search_test.rb
+homepage: https://rubygems.org/gems/smart_search
 licenses: []
 metadata: {}
 post_install_message: 
@@ -108,14 +41,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
-summary: Simple, easy to use search MySQL based search for ActiveRecord
+summary: Simple, easy to use search.
 test_files:
-- test/test_document_multi_line.txt
-- test/test_document_one_line.txt
 - 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
+- test/unit/smart_search_test.rb

data/config/database.yml

@@ -1,6 +0,0 @@
-test:
-  adapter: mysql2
-  database: smart_search_test
-  username: travis
-  password: 
-  encoding: utf8

data/lib/smart_search/engine.rb

@@ -1,12 +0,0 @@
-module SmartSearch
-  class Engine < Rails::Engine
-
-    engine_name 'smart_search'
-    
-    isolate_namespace SmartSearch
-    require "friendly_extensions"
-    require "amatch"
-
-  end
-end
-

data/lib/smart_search_history.rb

@@ -1,7 +0,0 @@
-# Saves all queries made so the data can be used to build a similarity index based on the queries made
-# by actual users of the website
-class SmartSearchHistory < ActiveRecord::Base
-  
-  
-  
-end  

data/lib/smart_search_tag.rb

@@ -1,16 +0,0 @@
-# Represents the search index
-class SmartSearchTag < ActiveRecord::Base
-  
-  
-  # Get a list of available search tags
-  def self.tags_list(query, table= nil)
-    if query.size < 3
-      return []
-    else  
-      list = sql_query!("select search_tags from #{self.table_name} where search_tags like '%#{query}%' #{"and table_name = '#{table}'" if table} ").map {|r| r['search_tags']}
-      list = list.join(" ").clear_html.split(" ").uniq
-      return list.sort.grep(Regexp.new(query))
-    end  
-  end  
-  
-end  

data/lib/smart_similarity.rb

@@ -1,133 +0,0 @@
-# This class is used to build similiarity index
-class SmartSimilarity < ActiveRecord::Base
-  #= Configuration
-  serialize :similarities, Array
-  self.table_name = "smart_search_similarities"
-  
-      #== Associations
-          # => Stuff in Here
-
-      #== Plugins and modules
-        #=== PlugIns
-          # => Stuff in Here        
-
-        #=== include Modules
-          # => Stuff in Here
-
-      #== Konstanten
-          # Defines the min. result of word simililarity check
-          SIMILARITY_FACTOR = 0.77
-          # Defines first simililarity check method 
-          SIMILARITY_METHOD_1 = :jarowinkler
-          # Defines first simililarity check method 
-          SIMILARITY_METHOD_2 = :levenshtein
-          
-          # An average of both results will generated and compered with 'SIMILARITY_FACTOR'
-          
-          # Limit Number of similar words (still unused)
-          SIMILARITY_LIMIT  = 8
-          
-          # USe this regexp to split texts into words
-          SPLITTING_REGEXP = /\b/
-          
-      #== Validation and Callbacks
-        #=== Validation
-        
-        #=== Callbacks
-          # => Stuff in Here
-    # => END
-  
-    # Create similarity data based on the given text
-    # This method is used to generate date from every source, e.g. file, url, single words etc..
-    def self.create_from_text(text)
-      # prepare text
-      prepared_text = text.downcase.split(SPLITTING_REGEXP).uniq
-      prepared_text = prepared_text.select {|w| w.size >= 3 && !w.match(/[0-9\-_<>\.\/(){}&\?"'@*+$!=,:'#;]/)}
-      list = {}
-      prepared_text.each do |word|
-        # Load index from database
-        words_in_db = self.find_by_phrase(word)
-        if words_in_db.nil?
-          self.connection.execute "INSERT INTO `#{self.table_name}` (`phrase`, `ind`) VALUES ('#{word}', '#{word[0..1]}');"
-          current = []
-        else  
-          current = words_in_db.similarities
-        end  
-          
-        # 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  
-      
-      # Write to Database
-      list.each do |word, sims|
-        sims = sims.sort_by {|s| self.match_words(s,word) }.reverse.first(SIMILARITY_LIMIT)
-        
-        self.connection.execute 'UPDATE %s set similarities = "%s" where phrase = "%s"' % [self.table_name, sims.to_yaml, word] rescue nil
-      end  
-    end
-    
-    # Add one simgle word to database and check if there are already similars
-    def self.add_word(word)
-      words = [word]
-      phrases = self.connection.select_all("SELECT phrase from smart_search_similarities").map {|r| r["phrase"] }  
-      words +=  phrases.select {|p| self.match_words(p,word) >= SIMILARITY_FACTOR }
-      
-      self.create_from_text(words.join(" "))
-    end
-    
-    # Load an entire file to the index.
-    # Best used for loading big dictionary files.
-    # Uses 'spawnling' to split the data into 8 stacks and load them simultaniously
-    def self.load_file(path)
-      count = %x{wc -l #{path}}.split[0].to_i.max(1)
-      puts "loading file: #{path}"
-      puts "=> #{count} rows"
-      
-      if count == 1
-        File.open(path, "r").read.split(SPLITTING_REGEXP).each {|w| self.add_word(w)}
-      else  
-        File.open(path, "r").read.split(SPLITTING_REGEXP).seperate([8,count].min).each_with_index do |stack, si| 
-            stack.each_with_index do |l,i|
-              self.add_word(l)
-            end
-        end
-      end    
-    end
-    
-    # Load words from website and save them to index
-    def self.load_url(url)
-      self.create_from_text(%x(curl #{url}))
-    end  
-    
-    # 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"]}
-      queries.each {|q| self.add_word(q) }
-      
-      self.connection.execute("TRUNCATE `#{::SmartSearchHistory.table_name}`")
-    end
-    
-    # Get array of similar words including orig word
-    def self.similars(word, options = {})      
-      list = self.where(:phrase => word).first
-      if list.nil?
-        return [word]
-      else
-        self.connection.execute("UPDATE `smart_search_similarities` SET `count` = #{list.count+1} where `smart_search_similarities`.`phrase` = '#{list.phrase}'")
-        return [word, list.similarities].flatten
-      end    
-    end
-    
-    # Return match score for two words bases und the two defined similarity methods
-    def self.match_words(word1, word2)
-      x1 = word1.send("#{SIMILARITY_METHOD_1}_similar", word2)
-      x2 = word1.send("#{SIMILARITY_METHOD_2}_similar", word2)
-      return (x1+x2)/2.0
-    end    
-  
-end 

data/lib/tasks/smart_search.rake

@@ -1,20 +0,0 @@
-namespace :smart_search do
-  desc "Load similarity data from query history"
-  task :similarity_from_query_history => :environment do
-    require File.expand_path("../../smart_similarity", __FILE__)
-    SmartSimilarity.load_from_query_history
-  end
-
-  desc "Load similarity data from url - Use URL=http://.../ to specify url - Requires 'curl'"
-  task :similarity_from_url => :environment do
-    require File.expand_path("../../smart_similarity", __FILE__)
-    if ENV['URL'].nil?
-      raise ArgumentError, "No URL specified. "
-    else
-      SmartSimilarity.load_url(ENV['URL'])
-    end
-  end
-
-end
-
-

data/lib/tasks/testing.rake

@@ -1,27 +0,0 @@
-require "active_record"
-namespace :db do
-  desc "Create test database. Overwrite dasebase config with USERNAME=, PASSWORD=, DATABASE="
-  task :create_test_db do
-    config = YAML::load(File.open(File.expand_path("config/database.yml")))["test"]
-    
-    # Overwrite config
-    config.merge!('database' => ENV['DATABASE']) if ENV['DATABASE']
-    config.merge!('username' => ENV['USERNAME']) if ENV['USERNAME']
-    config.merge!('password' => ENV['PASSWORD']) if ENV['PASSWORD']
-    
-    ActiveRecord::Base.establish_connection(config.merge('database' => nil))
-    ActiveRecord::Base.connection.drop_database(config['database']) rescue nil
-    ActiveRecord::Base.connection.create_database(config['database'])
-    ActiveRecord::Base.establish_connection(config)
-  end
-  
-  task :migrate do
-    ActiveRecord::Migrator.migrate(ActiveRecord::Migrator.migrations_paths)
-  end    
-end  
-
-task :test_smart_search do
-  Rake::Task["db:create_test_db"].execute
-  Rake::Task["db:migrate"].execute
-  Rake::Task["test"].execute
-end  

data/test/test_document_multi_line.txt

@@ -1,6 +0,0 @@
-The quick brown fox jumps over the lazy dog.
-The five boxing wizards jump quickly.
-Sphinx of all black quartz judge my vow.
-A quick movement of the enemy will jeopardize six gunboats.
-Five quacking Zephyrs jolt my wax bed.
-Heavy boxes perform waltzes and jigs.

data/test/test_document_one_line.txt

@@ -1 +0,0 @@
-Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

data/test/unit/02_smart_search_similarity_test.rb

@@ -1,32 +0,0 @@
-# -*- encoding : utf-8 -*-
-require "test_helper"
-class SmartSearchSimilartyTest < Test::Unit::TestCase
-  
-  def test_similarity_should_load_from_file
-    testfile_1 = File.expand_path("../../test_document_one_line.txt", __FILE__)
-    testfile_2 = File.expand_path("../../test_document_multi_line.txt", __FILE__)
-    SmartSimilarity.connection.execute "Truncate table #{SmartSimilarity.table_name}"
-    
-    assert_equal 0, SmartSimilarity.count
-    SmartSimilarity.load_file(testfile_2)
-    new_count = SmartSimilarity.count
-    assert_not_equal 0, new_count
-    
-    SmartSimilarity.load_file(testfile_1)
-    assert_not_equal new_count, SmartSimilarity.count
-  end
-  
-  def test_similarity_should_load_from_url
-    count = SmartSimilarity.count
-    SmartSimilarity.load_url("https://github.com/florianeck/smart_search")
-    assert_not_equal count, SmartSimilarity.count
-  end
-  
-  def test_similarity_should_load_from_history
-    count = SmartSimilarity.count
-    User.find_by_tags("this is history now")
-    SmartSimilarity.load_from_query_history
-    assert_not_equal count, SmartSimilarity.count
-  end      
-  
-end  

data/test/unit/03_smart_search_boost_test.rb

@@ -1,60 +0,0 @@
-# -*- 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