awesome_search 1.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Peter H. Boling (pboling on github)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,121 @@
+= Awesome Search
+
+* A helpful library to make searching more organized in the controller and views.
+* Using this library will force you to write a class for each kind of search you want to use.
+* It has features that allow easy configuration of searches tailored to work with rsolr.
+
+== Usage
+
+See tests.
+
+  AwesomeSearch.results_for_type_and_locale(":local :text this is a test", ":upc", ":ebay")
+
+== Configuration
+
+These are the settings used by the test suite.  Configure separately for each search class you create,
+or all at once for AwesomeSearch.
+
+  AwesomeSearch.configure_search_locales do |config|
+    config[:search_locales_to_classes] =
+      { ":local" =>   "SearchLocal",
+        ":amazon" =>  "SearchAmazon",
+        ":google" =>  "SearchGoogle",
+        ":ebay" =>    "SearchEbay" },
+    config[:search_locales_to_locale_modifiers] =
+      {
+        ":local" =>
+          [ ":local" ],
+        ":amazon" =>
+          [ ":amazon",
+            ":amzn",
+            ":amz",
+            ":am"],
+        ":google" =>
+          [ ":google",
+            ":goog",
+            ":goo",
+            ":go"],
+        ":ebay" =>
+          [ ":ebay",
+            ":eby",
+            ":eb"]
+      },
+    config[:locale_modifiers_to_search_locales] =
+      {
+        ":local"  => ":local",
+        ":amazon" => ":amazon",
+        ":amz"    => ":amazon",
+        ":amzn"   => ":amazon",
+        ":am"     => ":amazon",
+        ":google" => ":google",
+        ":goog"   => ":google",
+        ":goo"    => ":google",
+        ":go"     => ":google",
+        ":ebay"   => ":ebay",
+        ":eby"    => ":ebay",
+        ":eb"     => ":ebay"
+      }
+  end
+
+  AwesomeSearch.configure_search_types do |config|
+    config[:search_types_to_type_modifiers] =
+      {
+        ":isbn" => ":isbn",
+        ":sku" => ":sku",
+        ":upc" => ":upc",
+        ":asin" => ":asin",
+        ":id" => ":dbid",
+        ":text" => ":text"
+      },
+      # When using observer, how long should we wait before sending out search queries?
+    config[:search_type_inceptions] =
+      {
+        ":isbn" => 10,
+        ":sku" => 8,
+        ":upc" => 10,
+        ":asin" => 10,
+        ":id" => 1,
+        ":text" => 4
+      },
+    config[:search_type_regexes] =
+      {
+        ":isbn" => /\d{10}$|^\d{13}/,            #match 10 or 13 digits for isbn
+        ":sku" => /[0-9a-zA-Z\-]+/,              #match any alphanumeric
+        ":upc" => /\d{10}$|^\d{12}/,
+        ":asin" => /\w{10}/,
+        ":id" => /\d+/,
+        ":text" => /\w{4}/
+      }
+  end
+
+  Create subclasses like this:
+
+  #1. inherit from SuperSearch (which inherits from AwesomeSearch)
+    class SearchAmazon < SuperSearch
+  #2. Define a method called get_results
+    def get_results
+  #3. Always return nil unless super, as super's get_results will ensure the search is valid
+      return nil unless super
+  #4. Here is where you would do actual searching.  Write other methods and call them if need be or call methods in other classes, etc.
+      # You need to set the attribute 'found' to contain the search result(s).
+      # found is set to [] in the super, so you can iterate and do << with it,
+      # or set it to whatever you need it to be
+      self.found = Model.find(stuff) if stuff
+      nil
+    end
+  end
+
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+  Copyright (c) 2008-10 Peter H. Boling, released under the MIT license. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,72 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "awesome_search"
+    gem.summary = %Q{Organize complicated search results}
+    gem.description = %Q{Organize complicated search results}
+    gem.email = "peter.boling@peterboling.com"
+    gem.homepage = "http://github.com/pboling/awesome_search"
+    gem.authors = ["pboling"]
+    gem.add_development_dependency "shoulda", ">= 0"
+    gem.add_runtime_dependency "activesupport", ">= 2.1"
+    gem.files = [
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "awesome_search.gemspec",
+     "init.rb",
+     "lib/awesome/definitions/bits.rb",
+     "lib/awesome/definitions/filters.rb",
+     "lib/awesome/definitions/locales.rb",
+     "lib/awesome/definitions/types.rb",
+     "lib/awesome/search.rb",
+     "lib/awesome/super_search.rb",
+     "lib/awesome/triage.rb",
+     "lib/awesome_search.rb",
+     "rails/init.rb",
+     "init.rb"
+    ]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "awesome_search #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.1

data/awesome_search.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{awesome_search}
+  s.version = "1.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["pboling"]
+  s.date = %q{2010-04-29}
+  s.description = %q{Organize complicated search results}
+  s.email = %q{peter.boling@peterboling.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "awesome_search.gemspec",
+     "init.rb",
+     "lib/awesome/definitions/bits.rb",
+     "lib/awesome/definitions/filters.rb",
+     "lib/awesome/definitions/locales.rb",
+     "lib/awesome/definitions/types.rb",
+     "lib/awesome/search.rb",
+     "lib/awesome/super_search.rb",
+     "lib/awesome/triage.rb",
+     "lib/awesome_search.rb",
+     "rails/init.rb"
+  ]
+  s.homepage = %q{http://github.com/pboling/awesome_search}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Organize complicated search results}
+  s.test_files = [
+    "test/helper.rb",
+     "test/search_classes/amazon.rb",
+     "test/search_classes/ebay.rb",
+     "test/search_classes/google.rb",
+     "test/search_classes/local.rb",
+     "test/test_awesome_search.rb",
+     "test/test_multiple.rb",
+     "test/test_multiple_filters.rb",
+     "test/test_multiple_locales.rb",
+     "test/test_multiple_types.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.1"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 2.1"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 2.1"])
+  end
+end
+

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init"

data/lib/awesome/definitions/bits.rb

@@ -0,0 +1,74 @@
+module Awesome
+  module Definitions
+    module Bits
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        def get_class(name)
+          const_get(name) unless name.blank?
+        end
+
+        def modifier_regex_from_array(arr, whitespace = false)
+          self.modifier_regex(self.array_to_middle_regex(arr, whitespace))
+        end
+
+        def array_to_middle_regex(arr, whitespace = false)
+          return '' if arr.empty?
+          arr = whitespace ?
+            arr.map {|x| '(\s*' + x + '\s*)'} :
+            arr.map {|x| '(' + x + ')'}
+          arr.join('|')
+        end
+
+        def modifier_regex(middle)
+          Regexp.new(middle)
+        end
+
+        # In dealing with symbols and strings and params from requests
+        #  comparisons can fail even when we want them to pass.
+        # This prevents those unwanted failures
+        # We will compare strings of this format ":ebay"
+        def symring_equalizer(one, two)
+          return self.make_symring(one) == self.make_symring(two)
+        end
+
+        def make_symring(var)
+          if var.is_a?(Symbol)
+            return ":#{var}"
+          elsif var.is_a?(String)
+            var.include?(':') ? var.strip : ":#{var.strip}"
+          end
+        end
+
+        def unmake_symring(var)
+          return "#{var}".delete(':')
+        end
+
+        #def modifier_regex_from_arrays(arr, whitespace = false)
+        #  self.modifier_regex(array_of_arrays_to_middle_regex(arr, whitespace))
+        #end
+
+        #Returns a string of a partial regex
+        #def array_of_arrays_to_middle_regex(arr, whitespace = false)
+        #  arr = arr.map do |array|
+        #    "(" + self.array_to_middle_regex(array, whitespace) + ")"
+        #  end
+        #  arr.join('|')
+        #end
+
+        #def looped_array(a)
+        #  b = []
+        #  a.length.times do
+        #    b << Array.new(a.insert(0,a.pop))
+        #  end
+        #  b
+        #end
+
+      end
+    end
+  end
+end

data/lib/awesome/definitions/filters.rb

@@ -0,0 +1,72 @@
+module Awesome
+  module Definitions
+    module Filters
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.cattr_accessor :search_filters
+        base.cattr_accessor :verbose_filters
+      end
+
+      module ClassMethods
+
+        def search_filters_enabled
+          self.search_filter_keys(false)
+        end
+
+        def get_class_for_filter(filter)
+          self.get_class(self.search_filters[:search_filters_to_classes][filter])
+        end
+
+        def search_filter_keys(symring = true)
+          self.search_filters[:search_filters_to_filter_modifiers].map {|k,v| symring ? k : self.unmake_symring(k)}
+        end
+
+        def search_filter_modifiers(symring = true)
+          # Needs to be flattened because the values are arrays
+          self.search_filters[:search_filters_to_filter_modifiers].map {|k,v| symring ? v : self.unmake_symring(v)}.flatten
+        end
+
+        # filter param is an array of filters
+        def valid_filter_modifiers(anytext, filter)
+          # Weed out invalid filter requests
+          puts "checking valid_filter_modifiers: #{anytext}, filter: #{filter.inspect}" if self.verbose_filters
+          # We do not make_symring for two reasons:
+          #  1. people will use whatever kind of filter value they need, and ruby can compare it.
+          #  2. the filter param is an array
+          # #filter = self.make_symring(filter)
+          # Weed out invalid filter requests
+          allowed = (self.search_filter_keys & filter)
+          return false if !filter.empty? && allowed.empty?
+          valid_filter_mods = self.get_filter_modifiers(anytext, allowed)
+          valid_search_filters = valid_filter_mods.map do |fmod|
+            puts "filter mod #{fmod.inspect} => #{self.search_filters[:filter_modifiers_to_search_filters][fmod]}" if self.verbose_filters
+            self.search_filters[:filter_modifiers_to_search_filters][fmod]
+          end.compact
+          puts "valid_filter_modifiers: #{valid_search_filters.inspect}" if self.verbose_filters
+          return valid_search_filters
+        end
+
+        def get_filter_modifiers(anytext, filter = nil)
+          mods = anytext.scan(self.search_filter_modifiers_regex(false)).flatten.compact
+          #If no filter mods are in the search string then the filter requested is valid so we pretend it was requested as a modifier
+          mods = !filter.blank? && mods.empty? ? [self.make_symring(filter)] : mods
+          #mods = (self.search_filter_modifiers & mods) | filter
+          puts "get_filter_modifiers #{mods.reject {|x| x == ''}.inspect}" if self.verbose_filters
+          mods.reject {|x| x == ''}
+        end
+
+        def get_search_filter_from_modifier(mod)
+          self.search_filters[:filter_modifiers_to_search_filters][mod]
+        end
+
+        def search_filter_modifiers_regex(whitespace = false)
+          self.modifier_regex_from_array(self.search_filter_modifiers, whitespace)
+        end
+      end # end of ClassMethods
+
+      #INSTANCE METHODS
+
+    end
+  end
+end

data/lib/awesome/definitions/locales.rb

@@ -0,0 +1,69 @@
+module Awesome
+  module Definitions
+    module Locales
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.cattr_accessor :search_locales
+        base.cattr_accessor :verbose_locales
+      end
+
+      module ClassMethods
+
+        def stopwords_for_locale(locale)
+          self.search_locales[:search_locales_to_stopwords][locale]
+        end
+
+        def search_locales_enabled
+          self.search_locale_keys(false)
+        end
+
+        def get_class_for_locale(locale)
+          self.get_class(self.search_locales[:search_locales_to_classes][locale])
+        end
+
+        def search_locale_keys(symring = true)
+          self.search_locales[:search_locales_to_locale_modifiers].map {|k,v| symring ? k : self.unmake_symring(k)}
+        end
+
+        def search_locale_modifiers(symring = true)
+          # Needs to be flattened because the values are arrays
+          self.search_locales[:search_locales_to_locale_modifiers].map {|k,v| symring ? v : self.unmake_symring(v)}.flatten
+        end
+
+        def valid_locale_modifiers(anytext, locale)
+          # Weed out invalid locale requests
+          puts "checking valid_locale_modifiers: #{anytext}, locale: #{locale.inspect}" if self.verbose_locales
+          locale = self.make_symring(locale)
+          return false unless self.search_locale_keys.include?(locale)
+          mods = self.get_locale_modifiers(anytext, locale)
+          valid_mods = mods.select do |mod|
+            puts "locale mod #{mod.inspect} => #{self.get_search_locale_from_modifier(mod)} == #{locale.inspect}" if self.verbose_locales
+            self.symring_equalizer(self.get_search_locale_from_modifier(mod), locale)
+          end
+          puts "valid_locale_modifiers: #{valid_mods.inspect}" if self.verbose_locales
+          return valid_mods
+        end
+
+        def get_locale_modifiers(anytext, locale = nil)
+          mods = anytext.scan(self.search_locale_modifiers_regex(false)).flatten.compact
+          #If no locale mods are in the search string then the locale requested is valid so we pretend it was requested as a modifier
+          mods = !locale.blank? && mods.empty? ? [self.make_symring(locale)] : mods
+          puts "get_locale_modifiers: #{mods.reject {|x| x == ''}.inspect}" if self.verbose_locales
+          mods.reject {|x| x == ''}
+        end
+
+        def get_search_locale_from_modifier(mod)
+          self.search_locales[:locale_modifiers_to_search_locales][mod]
+        end
+
+        def search_locale_modifiers_regex(whitespace = false)
+          self.modifier_regex_from_array(self.search_locale_modifiers, whitespace)
+        end
+      end # end of ClassMethods
+
+      #INSTANCE METHODS
+
+    end
+  end
+end

data/lib/awesome/definitions/types.rb

@@ -0,0 +1,93 @@
+module Awesome
+  module Definitions
+    module Types
+      def self.included(base)
+        base.extend ClassMethods
+        base.cattr_accessor :search_types
+        base.cattr_accessor :verbose_types
+      end
+
+      module ClassMethods
+
+        def search_types_enabled
+          self.search_type_keys(false) - []
+        end
+
+        def search_type_keys(symring = true)
+          self.search_types[:search_types_to_type_modifiers].map {|k,v| symring ? k : self.unmake_symring(k)}
+        end
+
+        def search_type_modifiers(symring = true)
+          self.search_types[:search_types_to_type_modifiers].map {|k,v| symring ? v : self.unmake_symring(v)}
+        end
+
+        def type_modifiers_to_search_types
+          self.search_types[:search_types_to_type_modifiers].invert
+        end
+
+        # match a regex for the type
+        def match_types
+          return self.search_types[:search_type_regexes].map do |key,value|
+            self.search_query.match(value) ? key : nil
+          end.compact
+        end
+
+        # type param might be an array of types
+        def valid_type_modifiers(anytext, type, multiple_types_as_one = false)
+          puts "checking valid_type_modifiers: #{anytext}, type: #{type.inspect}, multiple_types_as_one: #{multiple_types_as_one}" if self.verbose_types
+          # Weed out invalid type requests
+          if multiple_types_as_one
+            #when using multiple types as one the keys are the modifiers, and the values are the search types
+            allowed = self.search_type_keys & type
+            valid_mods = allowed.map do |mod|
+              self.get_search_type_from_modifier(mod)
+            end.flatten.compact
+          else
+            #when NOT using multiple types as one the keys are the types, and the values are the modifiers
+            type = self.make_symring(type)
+            return [] unless self.search_type_keys.include?(type)
+            mods = self.get_type_modifiers(anytext, type)
+            searchie = self.type_modifiers_to_search_types
+            matchie = self.match_types
+            valid_mods = mods.select do |mod|
+              indy = matchie.index(searchie[mod])
+              puts "type mod #{mod.inspect} => #{searchie[mod].inspect} == #{indy ? matchie[indy].inspect : "nil"} == #{type.inspect}" if self.verbose_types
+              !indy.nil? &&
+                !matchie.nil? &&
+                !searchie.nil? &&
+                self.symring_equalizer(searchie[mod], type) && self.symring_equalizer(matchie[indy], type)
+#                (multiple_types_as_one ? type.include?(searchie[mod]) : self.symring_equalizer(searchie[mod], type)) &&
+#                (multiple_types_as_one ? type.include?(matchie[indy]) : self.symring_equalizer(matchie[indy], type))
+            end
+          end
+          puts "valid_type_modifiers: #{valid_mods.inspect}" if self.verbose_types
+          return valid_mods
+        end
+
+        def get_type_modifiers(anytext, type = nil, multiple_types_as_one = false)
+          mods = anytext.scan(self.search_type_modifiers_regex(false, multiple_types_as_one)).flatten.compact.reject {|x| x == ''}
+          #If no type mods are in the search string then the type requested is valid so we pretend it was requested as a modifier
+          mods = mods.empty? ? multiple_types_as_one ? type : [self.search_types[:search_types_to_type_modifiers][self.make_symring(type)]] : mods
+          puts "get_type_modifiers: #{mods.inspect}" if self.verbose_types
+          mods
+        end
+
+        def get_search_type_from_modifier(mod)
+          self.search_types[:search_types_to_type_modifiers][mod]
+        end
+        
+        def search_type_modifiers_regex(whitespace = false, multiple_types_as_one = false)
+          #return self.modifier_regex_from_arrays(self.looped_array(self.search_type_modifiers), whitespace)
+          self.modifier_regex_from_array(multiple_types_as_one ? self.search_type_keys : self.search_type_modifiers, whitespace)
+        end
+
+      end # end of ClassMethods
+
+      #INSTANCE METHODS
+      def valid_search_type_inception?
+        self.class.search_types[:search_type_inceptions][self.search_type] <= self.search_query.length
+      end
+
+    end
+  end
+end