search_generator 0.4 → 0.5

data/USAGE

@@ -9,13 +9,13 @@ SYNOPSIS
     Good names, anything that means search would be good.  Search,
     Forage, Frisk or Shakedown.
 
-    search has an additional option --inspect which will travers your
+    search has an additional option --inspect which will traverse your
     Model objects and tell you which ones could be made searchable
 
 DESCRIPTION
 
     This generator integrates the SimpleSearch search engine into a
-    rails applicaiton.  In addition, once configured for you site, it
+    rails application.  In addition, once configured for you site, it
     provides an Open Search (http://opensearch.a9.com/) compatible
     interface.
 
@@ -27,7 +27,7 @@ DESCRIPTION
             - Open Search RSS style results
         * an indexer to run periodically against your data to keep the
           search indexes up to date.
-        * a README on the additional hand coded tasks to intgerate
+        * a README on the additional hand coded tasks to integrate
           the search engine with your application         
 
 EXAMPLE

data/search_generator.rb

@@ -73,6 +73,10 @@ howto_make_searchable
                 # layout
                 m.template "app/views/layouts/layout.rhtml", "app/views/layouts/#{file_name}.rhtml"
 
+
+                # config
+                m.template "config/search.yml", "config/search.yml"
+
                 # views
                 m.directory File.join("app/views", class_path, file_name)
                 m.template "app/views/search/index.rhtml", "app/views/#{file_name}/index.rhtml"

data/templates/README

@@ -26,6 +26,29 @@
             make_searchable [ :title, :author, :content ]
         end 
 
+=== Configuration
+
+    A default configuration file 'search.yml' in installed in your
+    application config directory.  It should work as-is, but if you want
+    to move the simple search index file to a different location or
+    rename it, feel free to do so.  Just be aware that the index file
+    must be relative to RAILS_ROOT.  
+
+    Yes, if you look at the index file it does appear that other
+    backends could be available, but for now, there are no other search
+    backends besides SimpleSearch. 
+
+=== Index the data
+
+    Once your Models class are updated with make_searchable you'll need
+    to run script/indexer to crawl through your data and create the
+    index that is used to search the data.
+
+    Currently, this index is not automatically created and any new
+    content that is added to the database will not get indexed.  You
+    should have cron, or a scheduled task run the indexer periodically
+    to keep your index in sync with your data.
+
 === Routes
 
     Add the following lines to your config/routes.rb to hook in search
@@ -37,6 +60,9 @@
         map.connect 'rss/opensearch/description.xml', :controller => '<%= file_name %>', :action => 'description'
         map.connect 'rss/opensearch/:search_terms/:count', :controller => '<%= file_name %>', :action => 'rss', :count => '-1'  
 
+    Remember to put these routes before the default route or you will
+    get errors.
+
 === Layouts
 
     A 'very' basic layout/<%= file_name %>.rhtml is installed that shows the basic
@@ -61,21 +87,21 @@
        the results of your search that are of Article class.  
 
        The generic index.rhtml that is present will automatically use
-       the appropriate _parital.rhtml file based upon the class name if
+       the appropriate _partial.rhtml file based upon the class name if
        it is present.
 
     2. Open Search
 
-        This view is to return results in the format of OpenSearch RSS
-        (http://opensearch.a9.com/spec/opensearchrss/1.0/).  This
-        combined with the rss/opensearch Routes above and the 
-        description.rxml file found in this view should provide you with
-        an OpenSearch-able site.  
+       This view is to return results in the format of OpenSearch RSS
+       (http://opensearch.a9.com/spec/opensearchrss/1.0/).  This
+       combined with the rss/opensearch Routes above and the
+       description.rxml file found in this view should provide you with
+       an OpenSearch-able site.  
       
-        Again, you should create a _partial.rhtml file in this directory
-        for each Model you have that can return search results.  
+       Again, you should create a _partial.rhtml file in this directory
+       for each Model you have that can return search results.  
    
-        Also, the description.xml file should be configure with your
-        sites information.
+       Also, the description.xml file should be configure with your
+       sites information.
         
 

data/templates/app/controllers/controller.rb

@@ -12,16 +12,34 @@ class <%= class_name %>Controller < ApplicationController
     # return those to the caller
     #-----------------------------------------------------------------------
     def search
-        @search_terms = @params['search_terms'].split
+        @search_config = YAML.load(File.open(File.join(RAILS_ROOT,"config","search.yml")))
+
+        if @params['search_terms'].nil? then
+            @search_terms = @search_config['default_search_terms']
+        else 
+            @search_terms = @params['search_terms'].split
+        end
+
         @count        = @params['count'].to_i || -1
-        
+  
+        self.send("#{@search_config['search_backend']}_search")
+    end
+
+    def simple_search
+
         empty_contents = MockContents.new
-        simple_index = Search::Simple::Searcher.load(empty_contents,"#{File.dirname(__FILE__)}/../../db/search_cache") 
+
+        index_filename = File.join(RAILS_ROOT,@search_config['simple_backend']['index_filename'])
+
+        if not File.exists?(index_filename) then
+            raise "content index file (#{File.expand_path(index_filename)}) does not exist.  Did you run scripts/indexer ?"
+        end
+
+        simple_index = Search::Simple::Searcher.load(empty_contents,index_filename)
 
         # what to return to the caller
         @results = Array.new
 
-        # TODO: sort by score at some point ?
         search_results = simple_index.find_words(@search_terms)
 
         if search_results.contains_matches then
@@ -36,6 +54,7 @@ class <%= class_name %>Controller < ApplicationController
         @results.uniq!
     end
 
+
     def description
         @headers["Content-Type"] = "text/xml"
         render 'opensearch/description'

data/templates/config/search.yml

@@ -0,0 +1,10 @@
+---
+search_backend: "simple"
+    
+simple_backend: 
+    index_filename: db/simple_search_index
+
+default_search_terms:
+    - ruby
+    - search
+

data/templates/script/indexer

@@ -1,82 +1,97 @@
 #!/usr/bin/env ruby
 
-require "#{File.dirname(__FILE__)}/../config/environment"
+# load the rails environment
+require File.join(File.dirname(__FILE__),"..","config", "environment")
 
-require_gem "SimpleSearch"
+puts "Loading config [#{File.expand_path(File.join(RAILS_ROOT,"config","search.yml"))}]"
+SEARCH_CONFIG = YAML.load(File.open(File.join(RAILS_ROOT,"config","search.yml")))
 
 #-----------------------------------------------------------------------
-# the container for all the contents to be indexed
+# define how to build a index using SimpleSearch
 #-----------------------------------------------------------------------
-contents = Search::Simple::Contents.new
-
-#-----------------------------------------------------------------------
-# the current time is used to invalidate the Searcher's cache so it will
-# force an indexing
-#-----------------------------------------------------------------------
-ts = Time.now
-
-#-----------------------------------------------------------------------
-# iterate over all the files in the models directory looking for those
-# Models that are descendants of ActiveRecord
-#-----------------------------------------------------------------------
-puts "Searching for Models..."
-Dir.glob("#{File.dirname(__FILE__)}/../app/models/*.rb").each do |rbfile|
-
-    bname = File.basename(rbfile,'.rb')
-    classname = Inflector.camelize(bname)
-    classvar = eval(classname)
-    
-    if classvar.respond_to?(:descends_from_active_record?) and
-        classvar.descends_from_active_record? then
-        puts "\tFound #{classname} "
-
-    
-        #---------------------------------------------------------------
-        # if the class that is a dscendant from ActiveRecord also has
-        # the special method :searchable_fields then those fields are
-        # considered searchable
-        #---------------------------------------------------------------
-        if classvar.respond_to?(:searchable_fields) then
-
-            if not classvar.searchable_fields.nil?
-
-                cnames = classvar.searchable_fields.collect {|c| c.to_s}
-                puts "\t\t- searching columns #{cnames.join(",")}"
-                indexed_records = 0
-
-                #-----------------------------------------------------------
-                # now we interate over all the records of the particular
-                # type and record all the information for indexing.  
-                #-----------------------------------------------------------
-                classvar.find_all.each do |ar|
-                    record_id = "#{classname}.#{ar.send(classvar.primary_key)}"
-                    indexed_records = indexed_records + 1
-
-                    classvar.searchable_fields.each do |column|
-                        column_id = "#{record_id}.#{column.to_s}"
-                        data = ar.send(column)
-
-                        # only index non-nil content
-                        if not data.nil? then
-                            contents << Search::Simple::Content.new(ar.send(column), column_id, ts)
+def simple_index
+    require_gem "SimpleSearch"
+
+    #-----------------------------------------------------------------------
+    # the container for all the contents to be indexed
+    #-----------------------------------------------------------------------
+    contents = Search::Simple::Contents.new
+
+    #-----------------------------------------------------------------------
+    # the current time is used to invalidate the Searcher's cache so it will
+    # force an indexing
+    #-----------------------------------------------------------------------
+    ts = Time.now
+
+    #-----------------------------------------------------------------------
+    # iterate over all the files in the models directory looking for those
+    # Models that are descendants of ActiveRecord
+    #-----------------------------------------------------------------------
+    puts "Searching for Models..."
+    Dir.glob(File.join(RAILS_ROOT,"app","models","*.rb")).each do |rbfile|
+
+        bname = File.basename(rbfile,'.rb')
+        classname = Inflector.camelize(bname)
+        classvar = eval(classname)
+        
+        if classvar.respond_to?(:descends_from_active_record?) and
+            classvar.descends_from_active_record? then
+            puts "\tFound #{classname} "
+
+        
+            #---------------------------------------------------------------
+            # if the class that is a dscendant from ActiveRecord also has
+            # the special method :searchable_fields then those fields are
+            # considered searchable
+            #---------------------------------------------------------------
+            if classvar.respond_to?(:searchable_fields) then
+
+                if not classvar.searchable_fields.nil?
+
+                    cnames = classvar.searchable_fields.collect {|c| c.to_s}
+                    puts "\t\t- searching columns #{cnames.join(",")}"
+                    indexed_records = 0
+
+                    #-----------------------------------------------------------
+                    # now we interate over all the records of the particular
+                    # type and record all the information for indexing.  
+                    #-----------------------------------------------------------
+                    classvar.find_all.each do |ar|
+                        record_id = "#{classname}.#{ar.send(classvar.primary_key)}"
+                        indexed_records = indexed_records + 1
+
+                        classvar.searchable_fields.each do |column|
+                            column_id = "#{record_id}.#{column.to_s}"
+                            data = ar.send(column)
+
+                            # only index non-nil content
+                            if not data.nil? then
+                                contents << Search::Simple::Content.new(ar.send(column), column_id, ts)
+                            end
                         end
                     end
-                end
 
-                puts "\t\t- indexed #{indexed_records} records"
-            else
-                puts "\t\t- no make_searchable fields"
-            end 
+                    puts "\t\t- indexed #{indexed_records} records"
+                else
+                    puts "\t\t- no make_searchable fields"
+                end 
 
-        else
-            puts "\t\t- class is not searchable"
+            else
+                puts "\t\t- class is not searchable"
+            end
         end
     end
-end
 
-#-----------------------------------------------------------------------
-# this is where the actual indexing is done.  There previous sections of
-# code just collected the data to do the indexing.  
-#-----------------------------------------------------------------------
-s = Search::Simple::Searcher.load(contents,"#{File.dirname(__FILE__)}/../db/search_cache")
+    #-----------------------------------------------------------------------
+    # this is where the actual indexing is done.  There previous sections of
+    # code just collected the data to do the indexing.  
+    #-----------------------------------------------------------------------
+    index_file = File.join(RAILS_ROOT,SEARCH_CONFIG['simple_backend']['index_filename'])
+    puts "creating index file #{File.expand_path(index_file)}"
+    s = Search::Simple::Searcher.load(contents,index_file)
+end
 
+case SEARCH_CONFIG['search_backend']
+when 'simple'
+    simple_index
+end

data/templates/script/searcher

@@ -1,8 +1,12 @@
 #!/usr/bin/env ruby
 
-require "#{File.dirname(__FILE__)}/../config/environment"
+require File.join(File.dirname(__FILE__),"..","config","environment")
 
 require_dependency "search_system"
+#-----------------------------------------------------------------------
+# load the config
+#-----------------------------------------------------------------------
+search_config = YAML.load(File.open(File.join(RAILS_ROOT,"config","search.yml")))
 
 #-----------------------------------------------------------------------
 # grab the first word on the command line as the term to search for
@@ -11,28 +15,31 @@ search_terms = Array.new
 if ARGV.size > 0 then
     search_terms << ARGV[0]
 else
-    puts "no search term given, searching for 'ruby'"
-    search_terms << "ruby"
+    puts "no search term given, searching for #{search_config['default_search_terms'].join(',')}"
+    search_terms = search_config['default_search_terms']
 end
 
-#-----------------------------------------------------------------------
-# a mock contents so that we use the cache
-#-----------------------------------------------------------------------
-contents = MockContents.new
-s = Search::Simple::Searcher.load(contents,"#{File.dirname(__FILE__)}/../db/search_cache")
+case search_config['search_backend'] 
+when 'simple'
+    #-----------------------------------------------------------------------
+    # a mock contents so that we use the cache
+    #-----------------------------------------------------------------------
+    contents = MockContents.new
+    s = Search::Simple::Searcher.load(contents,search_config['simple_backend']['index_filename'])
 
-#-----------------------------------------------------------------------
-# do the search
-#-----------------------------------------------------------------------
-sr = s.find_words(search_terms)
+    #-----------------------------------------------------------------------
+    # do the search
+    #-----------------------------------------------------------------------
+    sr = s.find_words(search_terms)
 
-if sr.contains_matches then
-    puts "Score\t#File"
-    sr.results.sort.each do |res|
-        puts "#{res.score}\t#{res.name}"
+    if sr.contains_matches then
+        puts "Score\t#File"
+        sr.results.sort.each do |res|
+            puts "#{res.score}\t#{res.name}"
+        end
+    else
+        puts sr.warnings
+        puts "No matches"
     end
-else
-    puts sr.warnings
-    puts "No matches"
+        
 end
-    

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: search_generator
 version: !ruby/object:Gem::Version 
-  version: "0.4"
-date: 2005-04-11
+  version: "0.5"
+date: 2005-04-24
 summary: "[Rails] Search generator."
 require_paths: 
   - "."
@@ -30,10 +30,12 @@ files:
   - USAGE
   - LICENSE
   - search_generator.rb
+  - templates/config
   - templates/README
   - templates/lib
   - templates/app
   - templates/script
+  - templates/config/search.yml
   - templates/lib/search_system.rb
   - templates/app/controllers
   - templates/app/views