search_generator 0.4

data/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2005 Jeremy Hinegardner <jeremy@hinegardner.org>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright 
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright 
+      notice, this list of conditions and the following disclaimer in
+      the documentation and/or other materials provided with the
+      distribution.
+
+    * The name of the author may not be used to endorse or promote 
+      products derived from this software without specific prior written
+      permission from the author.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/USAGE

@@ -0,0 +1,50 @@
+NAME
+
+    search - a search engine that can be added to any Rails application
+
+SYNOPSIS
+
+    search [Search name] [options]
+
+    Good names, anything that means search would be good.  Search,
+    Forage, Frisk or Shakedown.
+
+    search has an additional option --inspect which will travers 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
+    provides an Open Search (http://opensearch.a9.com/) compatible
+    interface.
+
+    Included:
+
+        * a Controller to manage search request
+        * Views to customize for your Model objects
+            - regular html results
+            - 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
+          the search engine with your application         
+
+EXAMPLE
+
+    ./script/generate search Search
+
+        This will create a basic search engine framework for you to
+        customize for your site.
+
+    ./script/generate search Search --inspect
+
+        This will report which ones of your Model classes could be made
+        searchable.
+
+DEPENDENCIES
+
+    - SimpleSearch (http://www.chadfowler.com/SimpleSearch)
+        Install : gem install SimpleSearch
+
+

data/search_generator.rb

@@ -0,0 +1,97 @@
+class SearchGenerator < Rails::Generator::NamedBase
+
+    def add_options!(opt)
+        opt.on('-i', '--inspect','Inspect models to see which ones can be searchable') { |value| options[:inspect] = true }
+    end
+
+    def inspect
+        puts <<howto_make_searchable
+The following Models, and their associated fields, 
+in your application can be made searchable.  Just copy
+and paste the 'make_searchable' line from the report below 
+into the approrpaite models file (also reported below).
+
+The 'make_searchable' line reports all the searchable fields
+in that model.  You probably do not want all of the fields 
+in your Model, so edit the line as appropriate
+
+IMPORTANT:
+
+    Make sure to the following line to the top of any model file 
+    you edit to make searchable.
+
+    require_dependency "search_system" 
+
+howto_make_searchable
+
+        Dir.glob(File.join(@destination_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
+                attrs = classvar.columns_hash.keys.collect { |a| ":" + a.to_s}
+
+                puts "-----[ #{classname} => #{File.expand_path(rbfile)} ]-----"
+                if classvar.respond_to?(:searchable_fields) then
+                    fields = classvar.searchable_fields
+                    if fields.nil? or fields.size == 0 then
+                        puts "#{classname} is searchable, but no fields are selected."
+                        puts
+                        puts "  make_searchable  [ #{attrs.join(", ")} ]"
+                    else
+                        fields = fields.collect { |f| ":" + f.to_s }
+                        puts "#{classname} has the following fields marked as searchable:"
+                        puts
+                        puts "    [ #{fields.join(", ")} ]"
+                    end
+                else
+                    puts "  make_searchable  [ #{attrs.join(", ")} ]"
+                end
+                puts 
+            end
+        end
+        puts
+    end
+
+    def remove
+        manifest.rewind(Rails::Generator::Command::Destroy)
+    end
+
+    def manifest
+        record do |m|
+
+            if options[:inspect] then
+                m.inspect
+            else
+                # system
+                m.template "lib/search_system.rb", "lib/search_system.rb"
+
+                # controller
+                m.template "app/controllers/controller.rb", "app/controllers/#{file_name}_controller.rb"
+
+                # layout
+                m.template "app/views/layouts/layout.rhtml", "app/views/layouts/#{file_name}.rhtml"
+
+                # views
+                m.directory File.join("app/views", class_path, file_name)
+                m.template "app/views/search/index.rhtml", "app/views/#{file_name}/index.rhtml"
+                m.template "app/views/search/_generic.rhtml", "app/views/#{file_name}/_generic.rhtml"
+
+                m.directory "app/views/opensearch"
+                m.template "app/views/opensearch/rss.rhtml", "app/views/opensearch/rss.rhtml"
+                m.template "app/views/opensearch/description.rxml", "app/views/opensearch/description.rxml"
+                m.template "app/views/opensearch/_generic.rhtml", "app/views/opensearch/_generic.rhtml"
+               
+                # scripts
+                m.template "script/indexer", "script/indexer", :chmod => 0755 
+                m.template "script/searcher", "script/searcher", :chmod => 0755
+
+                # custom to this generation install README
+                m.template "README", "README_SEARCH"
+            end
+
+        end
+    end
+
+end

data/templates/README

@@ -0,0 +1,81 @@
+== Installation
+
+    After the search engine has been generated, there are still tasks to
+    fully integrate the search engine into your site.
+
+=== Inspect
+
+    execute:
+
+        script/generate search <%= class_name %> --inspect 
+
+    This will report which of your models can be made searchable.  Feel
+    free to run it many times.
+
+=== Models 
+
+    In each of your Models in which you want to have the content
+    searched, and are ActiveRecord descendants, you need to add a
+    require_dependency "search_system".  Then you are able to invoke the
+    class method 'make_searchable' with an Array of field symbols.
+
+    For example:
+            
+        require_dependency "search_system"
+        class Article < ActiveRecord::Base
+            make_searchable [ :title, :author, :content ]
+        end 
+
+=== Routes
+
+    Add the following lines to your config/routes.rb to hook in search
+
+        # allow for searching view the route
+        map.connect '<%= file_name %>/:search_terms/:count', :controller => '<%= file_name %>', :action => 'index', :count => '-1' 
+
+        # allow for Open Search RSS feeds searching
+        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'  
+
+=== Layouts
+
+    A 'very' basic layout/<%= file_name %>.rhtml is installed that shows the basic
+    results.  This should be customized for your site.  
+
+=== Views
+
+    Two new views have been added to your rails application.
+
+    1. Search
+
+       This view should be customized for your site so that the search
+       results fit in well with your site.  The default _partial
+       template that exists will render out a generic table showing all
+       the fields and their values for the search results.  You should
+       customize the index.rhtml file to integrate with your site, and
+       you should create a _partial.rhtml for each Model that you could
+       have search results for.
+
+       That is, if you have an application with an Article Model, you
+       should create a _article.rhtml file in this view to render out
+       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
+       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.  
+      
+        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.
+        
+

data/templates/app/controllers/controller.rb

@@ -0,0 +1,48 @@
+require_dependency "search_system"
+
+class <%= class_name %>Controller < ApplicationController
+    layout "<%= file_name %>" , :except => [:rss, :description]
+    
+    def index 
+        search
+    end
+
+    #-----------------------------------------------------------------------
+    # search through the index, get the ActiveRecord's that match and
+    # return those to the caller
+    #-----------------------------------------------------------------------
+    def search
+        @search_terms = @params['search_terms'].split
+        @count        = @params['count'].to_i || -1
+        
+        empty_contents = MockContents.new
+        simple_index = Search::Simple::Searcher.load(empty_contents,"#{File.dirname(__FILE__)}/../../db/search_cache") 
+
+        # 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
+            search_results.results.sort.each do |result|
+                (classname,pk_id,column) = result.name.split(".")
+                classvar = eval(classname)
+                @results << classvar.find(pk_id)
+                break if @count > 0 and @results.size >= @count 
+            end
+        end
+
+        @results.uniq!
+    end
+
+    def description
+        @headers["Content-Type"] = "text/xml"
+        render 'opensearch/description'
+    end
+    def rss
+        @headers["Content-Type"] = "text/xml"
+        search
+        render 'opensearch/rss'
+    end
+end

data/templates/app/views/layouts/layout.rhtml

@@ -0,0 +1,25 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+    <head>
+        <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+        <title>SITE TITLE</title>
+    </head>
+    <body>
+
+            <h1>Search SITE</h1>
+            
+            <form action="/search" method="get">
+                <%% if @search_terms.size > 0 %>
+                <input type="text" name="search_terms" value="<%%= @search_terms.join(" ") %>" size="30" />
+                <%% else %>
+                <input type="text" name="search_terms" value="" size="30" />
+                <%% end %>
+            </form>
+
+            <hr />
+
+            <h2>Results</h2>
+            <%%= @content_for_layout %>
+
+    </body>
+</html>

data/templates/app/views/opensearch/_generic.rhtml

@@ -0,0 +1,11 @@
+<title><%%= generic.class.name %></title>
+<link>INSERT CODE TO GET LINK TO THIS ITEM</link>
+<description>
+<div class="record">
+    <table>
+            <%% generic.class.searchable_fields.each do |field| %>
+            <tr> <th><%%= field.to_s %></th> <td><%%= generic.send(field) %></td> </tr>
+            <%% end %>
+    </table> 
+</div>
+</description>

data/templates/app/views/opensearch/description.rxml

@@ -0,0 +1,9 @@
+xml.OpenSearchDescription(:xmlns => "http://a9.com/-/spec/opensearchrss/1.0/") do
+    xml.url("http://localhost:3000/opensearch/{searchTerms}/{count}")
+    xml.format("http://a9.com/-/spec/opensearchrss/1.0/")
+    xml.shortname("site shortname")
+    xml.longname("site longname")
+    xml.description("site description")
+    xml.syndicationright("open")
+    xml.adultcontent("false")
+end

data/templates/app/views/opensearch/rss.rhtml

@@ -0,0 +1,23 @@
+<?xml version="1.0"?>
+  <rss version="1.0" xmlns:openSearch="http://a9.com/-/spec/opensearchrss/1.0/">
+  <channel>
+      <title>Site title</title>
+      <link><%%= @request.env['REQUEST_URI'] %></link>
+      <description>Site description</description>
+      <language>en-us</language>
+      <copyright>&amp;copy;2003-2005, site its affiliates.</copyright>
+      <openSearch:totalResults><%%= @results.size %></openSearch:totalResults>
+      <openSearch:startIndex>1</openSearch:startIndex>
+      <openSearch:itemsPerPage><%%= @results.size %></openSearch:itemsPerPage>
+
+
+      <%% for result in @results %>
+            <%% begin %>
+            <%%= render_partial "opensearch/#{Inflector.underscore(result.class)}", result %>
+            <%% rescue ActionView::ActionViewError %>
+            <%%= render_partial "opensearch/generic", result %>
+            <%% end %>
+       <%% end %>
+  </channel>
+  </rss>
+

data/templates/app/views/search/_generic.rhtml

@@ -0,0 +1,7 @@
+<div class="record">
+    <table>
+            <%% generic.class.searchable_fields.each do |field| %>
+            <tr> <th><%%= field.to_s %></th> <td><%%= generic.send(field) %></td> </tr>
+            <%% end %>
+    </table> 
+</div>

data/templates/app/views/search/index.rhtml

@@ -0,0 +1,14 @@
+<%% @results.each do |result|  %>
+<hr />
+
+<%%# Try to render a partial based upon the class name %>
+<%%# but if that does not work, reneder a generic one %>
+
+    <%%  begin %>
+    <%%= render_partial Inflector.underscore(result.class), result %>
+    <%%  rescue ActionView::ActionViewError %>
+    <pre>No parital available for <%%= result.class %>, using generic </pre>
+    <%%= render_partial "generic", result %>
+    <%%  end %>
+
+<%% end %>

data/templates/lib/search_system.rb

@@ -0,0 +1,20 @@
+require_gem "SimpleSearch"
+
+class ActiveRecord::Base
+
+    def self.make_searchable(list_of_field_symbols)
+        @searchable_fields = list_of_field_symbols
+    end
+
+    def self.searchable_fields
+        @searchable_fields
+    end
+
+end
+
+class MockContents
+    def latest_mtime
+        Time.at(0)
+    end
+end
+

data/templates/script/indexer

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require "#{File.dirname(__FILE__)}/../config/environment"
+
+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.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)
+                        end
+                    end
+                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"
+        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")
+

data/templates/script/searcher

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require "#{File.dirname(__FILE__)}/../config/environment"
+
+require_dependency "search_system"
+
+#-----------------------------------------------------------------------
+# grab the first word on the command line as the term to search for
+#-----------------------------------------------------------------------
+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"
+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")
+
+#-----------------------------------------------------------------------
+# 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}"
+    end
+else
+    puts sr.warnings
+    puts "No matches"
+end
+    

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: search_generator
+version: !ruby/object:Gem::Version 
+  version: "0.4"
+date: 2005-04-11
+summary: "[Rails] Search generator."
+require_paths: 
+  - "."
+email: jeremy@hinegardner.org
+homepage: 
+rubyforge_project: 
+description: Generates Rails code implementing a search system using SimpleSearch for your Rails app.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Jeremy Hinegardner
+files: 
+  - USAGE
+  - LICENSE
+  - search_generator.rb
+  - templates/README
+  - templates/lib
+  - templates/app
+  - templates/script
+  - templates/lib/search_system.rb
+  - templates/app/controllers
+  - templates/app/views
+  - templates/app/controllers/controller.rb
+  - templates/app/views/search
+  - templates/app/views/opensearch
+  - templates/app/views/layouts
+  - templates/app/views/search/index.rhtml
+  - templates/app/views/search/_generic.rhtml
+  - templates/app/views/opensearch/_generic.rhtml
+  - templates/app/views/opensearch/rss.rhtml
+  - templates/app/views/opensearch/description.rxml
+  - templates/app/views/layouts/layout.rhtml
+  - templates/script/indexer
+  - templates/script/searcher
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rails
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">="
+          - !ruby/object:Gem::Version 
+            version: 0.10.0
+      version: 
+  - !ruby/object:Gem::Dependency 
+    name: SimpleSearch
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">="
+          - !ruby/object:Gem::Version 
+            version: 0.5.0
+      version: