awesome_search 1.0.1

data/lib/awesome/search.rb

@@ -0,0 +1,146 @@
+module Awesome
+  class Search
+
+    # Mixins
+    include Definitions::Bits
+    include Definitions::Types
+    include Definitions::Filters
+    include Definitions::Stopwords
+
+    @@search_types ||= {:search_types_to_type_modifiers => {},
+                        :search_type_inceptions => {},
+                        :search_type_regexes => {}}
+    @@search_filters ||= {:search_filters_to_filter_modifiers => {},
+                          :filter_modifiers_to_search_filters => {}}
+
+    #Some defaults if stopwords are set to be used (by default they are turned off)
+    @@search_stopwords ||= {:standard => %w(an and are as at be but by for if in into is it no not of on or s such t that the their then there these they this to was will with),
+                            :custom => []}
+
+    def self.configure_search_types(&block)
+      yield @@search_types
+    end
+
+    def self.configure_search_filters(&block)
+      yield @@search_filters
+    end
+
+    def self.configure_search_stopwords(&block)
+      yield @@search_stopwords
+    end
+
+    #TODO: Put these into a config block
+    cattr_accessor :verbose
+    cattr_accessor :check_inception
+    cattr_accessor :protect_types
+    cattr_accessor :protect_filters
+
+    attr_accessor(:search_text,
+                  :search_query,
+                  :search_type,
+                  :search_filters,
+                  :search_locale,
+                  :stopwords,
+                  :found,
+                  :tally,
+                  :success,
+                  :endpoint,
+                  :invalid_inception,
+                  :redirect_url,
+                  :page,
+                  :per_page,
+                  :replacement_for,
+                  :multiple_types_as_one,
+                  :tokenize_quoted,
+                  :tokenize_unquoted,
+                  :tokenize_without_quoted,
+                  :quoted_exact_phrases,
+                  :unquoted_exact_phrases,
+                  :query_without_exact_phrases,
+                  :gowords,
+                  :search_tokens,
+                  :highlight_tokens)
+
+    #CLASS METHODS
+    #Main focus of class methods is determining which sort of AwesomeSearch subclass we need to instantiate for the search
+    def initialize(*args)
+      @multiple_types_as_one = args.first[:multiple_types_as_one]
+      @stopwords =  args.first[:stopwords] ?
+                      args.first[:stopwords].is_a?(Array) ?
+                        args.first[:stopwords] :
+                        args.first[:stopwords].is_a?(Symbol) ?
+                          self.class.stopwords(args.first[:stopwords]) :
+                          self.class.stopwords(:both) :
+                      args.first[:stopwords] != false ?
+                        self.class.stopwords(:standard) :
+                        []
+      @page     = args.first[:page]
+      @per_page = args.first[:per_page]
+      @search_text =    args.first[:search_text]    # a string
+      @search_filters = args.first[:search_filters] # a ruby object (string, array, hash) to be used by subclasss search classes as a filter
+      #Chicken-egg problem: search_tokens and highlight_tokens both need to be set within clean_search_text (and they are!) because they must work with the text cleaned by the clean_search_text methods
+      @search_tokens =  args.first[:search_tokens]  # an array of the query terms as tokens after being cleaned, unless passed in as param (not sure why this would ever be desired, but why not allow it jic?) When not set in args, will be set by clean_search_text methods
+      @highlight_tokens =  args.first[:highlight_tokens]  # an array of the query terms as unquoted tokens after being cleaned, unless passed in as param (not sure why this would ever be desired, but why not allow it jic?) When not set in args, will be set by clean_search_text methods
+      @search_query =   self.clean_search_text      # a string to be set based on the search text by removing the search modifiers from the search text
+      @search_type =    args.first[:search_type]    # a symring (symring methods are in the Bits mixin)
+      @search_locale =  args.first[:search_locale]  # a symring (symring methods are in the Bits mixin)
+      @found = nil
+      @tally = nil
+      @success = true
+      @redirect_url = nil
+      @replacement_for = nil # stores the name of, or explanatory text about, the primary search if this search is a secondary (replacement) search for a primary search that returned no results
+      if self.class.check_inception && !self.valid_search_type_inception?
+        puts "search type inception is invalid (no type regex matches query string)" if Awesome::Search.verbose
+        @invalid_inception = true
+      end
+    end
+
+    def to_s
+      "search_query: #{self.search_query} \
+\n\rsearch_tokens: #{self.search_tokens.inspect} \
+\n\rhighlight_tokens: #{self.highlight_tokens.inspect} \
+\n\rtally: #{self.tally} \
+\n\rsuccess? #{self.success ? 'Yes' : 'No'}"
+    end
+
+    def clean_search_text
+      txt = Awesome::Triage.clean_search_text(self.search_text)
+      txt = Awesome::Search.clean_search_text(txt, self.multiple_types_as_one)
+      txt = self.process_stopwords(txt)
+      txt
+    end
+
+    def self.clean_search_text(text, multiple_types_as_one = false)
+      txt = text.gsub(self.search_type_modifiers_regex(true, multiple_types_as_one), "")
+      txt.gsub(self.search_filter_modifiers_regex(true), "")
+    end
+
+    # Main method used by the app to search
+    # Instantiates an Awesome::Triage which will handle setting up the search
+    def self.results_for(anytext, types, locales, filters = nil, multiple_types_as_one = false, page = nil, per_page = nil)
+      # 1. if the search is blank return nil
+      puts "anytext is blank" if Awesome::Search.verbose && anytext.blank?
+      return nil if anytext.blank?
+      Triage.new(:text => anytext, :types => types, :locales => locales, :filters => filters, :multiple_types_as_one => multiple_types_as_one, :page => page, :per_page => per_page)
+    end
+
+    #INSTANCE METHODS
+
+    # get_results is called on the instances of the subclasses.
+    # The subclasses override the methods called within it to return their customized stuff
+    # The subclasses call super to ensure that the data is valid before sending out the search.
+    def get_results
+      # 1. if the search is blank do NOT run the search (handled in subclasses)
+      !self.search_text.blank? && !self.search_query.blank? && !self.search_type.blank? && !self.search_locale.blank?
+    end
+  end
+end
+
+#handles a param of any string, and returns all known matches for that string
+#def self.all_matches(search_text = "")
+#  self.match_types(search_text).map do |type|
+#    {type => self.matches_for_type(type, search_text, true)}
+#  end.compact | self.match_types(search_text).map do |type|
+#    {type => self.matches_for_type(type, search_text, false)}
+#  end.compact
+#end

data/lib/awesome/super_search.rb

@@ -0,0 +1,16 @@
+module Awesome
+  class SuperSearch < Awesome::Search
+    # Instance method Mixins
+    def get_results
+      return nil unless super
+      # initialize the search result values since
+      # if we've gotten this far we have a real search being executed
+      # tally and results are set to nil in the main initializer
+      # so that we can differentiate between searches that aborted
+      # and searches that completed but had no results.
+      self.found = []
+      self.tally = 0
+      return true
+    end
+  end
+end

data/lib/awesome/triage.rb

@@ -0,0 +1,122 @@
+module Awesome
+  class Triage < Array
+
+    # Mixins
+    include Definitions::Bits
+    include Definitions::Locales
+
+    #The following is set in a config block
+    @@search_locales ||= {:search_locales_to_classes => {},
+                          :search_locales_to_locale_modifiers => {},
+                          :locale_modifiers_to_search_locales => {},
+                          :search_locales_to_stopwords => {}}
+
+    def self.configure_search_locales(&block)
+      yield @@search_locales
+    end
+
+    #TODO: Put these into a config block
+    cattr_accessor :verbose
+
+    attr_accessor( :text,
+                   :types,
+                   :locales,
+                   :filters,
+                   :multiple_types_as_one,
+                   :redirect_url,
+                   :page,
+                   :per_page )
+
+    def initialize(*args)
+      super()
+      @multiple_types_as_one = !args.first[:multiple_types_as_one].nil? ? args.first[:multiple_types_as_one] : false# Boolean: should the array of types be sent through to a single search, or iterated over to separate searches like locales?
+      @page     = args.first[:page]
+      @per_page = args.first[:per_page]
+      @text     = args.first[:text]     # a string
+      @types    = args.first[:types].respond_to?(:each) ? args.first[:types] : [args.first[:types]]       # a symring, or array thereof (symring methods are in the Bits mixin)
+      @locales  = args.first[:locales].respond_to?(:each) ? args.first[:locales] : [args.first[:locales]] # a symring, or array thereof (symring methods are in the Bits mixin)
+      @filters  = args.first[:filters] # a ruby object (string, array, hash) to be used by subclasss search classes as a filter
+      @redirect_url = nil
+      # 1. Handle all locale modifiers, by creating a different search for each
+      self.locales.each do |locale|
+        puts "initializing locale: #{locale}" if self.class.verbose_locales
+        locale = self.class.make_symring(locale)
+        klass = self.class.get_class_for_locale(locale)
+        # 2. if there is no matching class for the locale return nil
+        puts "klass is nil" if Awesome::Triage.verbose && klass.nil?
+        next if klass.nil?
+        # 3. If there is a locale modifier, then make sure it matches the locale being searched or return nil
+        locale_mods = self.class.valid_locale_modifiers(self.text, locale)
+        puts "locale_mods is empty" if Awesome::Triage.verbose && locale_mods.empty?
+        next if locale_mods.empty?
+        self.add_search(klass, locale, self.class.stopwords_for_locale(locale))
+        #if we hit a search that tells us to redirect, do not continue
+        break if self.redirect_url
+      end
+      self.compact!
+      self
+    end
+
+    def add_search(klass, locale, stopwords)
+      # 4. Handle all type modifiers, by creating a different search for each
+      if self.multiple_types_as_one
+        new_search = self.new_search_for_types_and_locale(klass, self.types, locale, stopwords)
+        self.redirect_url = new_search.redirect_url
+        self << new_search
+      else
+        self.types.each do |typ|
+          new_search = self.new_search_for_type_and_locale(klass, typ, locale, stopwords)
+          self.redirect_url = new_search.redirect_url
+          self << new_search
+        end
+      end
+    end
+
+    # single type
+    def new_search_for_type_and_locale(klass, type, locale, stopwords)
+      new_search = nil
+      type = self.class.make_symring(type)
+      # 6. If there is a type modifier, then make sure it matches the type being searched or return nil
+      valid_type_mods = Awesome::Search.protect_types ? klass.valid_type_modifiers(self.text, type, self.multiple_types_as_one) : [type]
+      puts "valid_type_mods is empty" if Awesome::Triage.verbose && valid_type_mods.empty?
+      unless valid_type_mods.empty?
+        new_search = klass.new({:stopwords => stopwords, :multiple_types_as_one => self.multiple_types_as_one, :search_text => self.text, :search_type => type, :search_locale => locale, :search_filters => self.filter_mods(klass), :page => self.page, :per_page => self.per_page})
+        new_search.get_results
+      end
+      return new_search
+    end
+
+    # multiple types
+    def new_search_for_types_and_locale(klass, types, locale, stopwords)
+      new_search = nil
+      # 6. If there is a type modifier, then make sure it matches the type being searched or return nil
+      valid_type_mods = klass.protect_types ? klass.valid_type_modifiers(self.text, types, self.multiple_types_as_one) : types
+      puts "valid_type_mods is empty" if Awesome::Triage.verbose && valid_type_mods.empty?
+      unless valid_type_mods.empty?
+        new_search = klass.new({:stopwords => stopwords, :multiple_types_as_one => self.multiple_types_as_one, :search_text => self.text, :search_type => valid_type_mods, :search_locale => locale, :search_filters => self.filter_mods(klass), :page => self.page, :per_page => self.per_page})
+        new_search.get_results
+      end
+      return new_search
+    end
+
+    def filter_mods(klass)
+      valid_filter_mods = nil
+      if self.filters
+        # 5. If there is a filter modifier, then make sure it matches the locale being searched or return nil
+        valid_filter_mods = Awesome::Search.protect_filters ? klass.valid_filter_modifiers(self.text, self.filters) : self.filters
+        puts "valid_filter_mods is empty" if Awesome::Triage.verbose && valid_filter_mods.empty?
+      end
+      valid_filter_mods
+    end
+
+    def clean_search_text
+      txt = Awesome::Triage.clean_search_text(self.search_text)
+      Awesome::Search.clean_search_text(txt, self.multiple_types_as_one)
+    end
+
+    def self.clean_search_text(text)
+      text.gsub(self.search_locale_modifiers_regex(true), "")
+    end
+
+  end
+end

data/lib/awesome_search.rb

@@ -0,0 +1,7 @@
+require "awesome/definitions/bits" unless defined?(Awesome::Definitions::Bits)
+require "awesome/definitions/locales" unless defined?(Awesome::Definitions::Locales)
+require "awesome/definitions/filters" unless defined?(Awesome::Definitions::Filters)
+require "awesome/definitions/types" unless defined?(Awesome::Definitions::Types)
+require "awesome/triage" unless defined?(Awesome::Triage)
+require "awesome/search" unless defined?(Awesome::Search)
+require "awesome/super_search" unless defined?(Awesome::SuperSearch)

data/rails/init.rb

@@ -0,0 +1,3 @@
+require "active_support" unless defined?(ActiveSupport)
+
+require "awesome_search" unless defined?(Awesome::Search)

data/test/helper.rb

@@ -0,0 +1,128 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require File.join(File.dirname(__FILE__), "..", "init")
+
+require "test/search_classes/amazon"
+require "test/search_classes/ebay"
+require "test/search_classes/google"
+require "test/search_classes/local"
+
+class Test::Unit::TestCase
+  Awesome::Search.protect_types = true
+  Awesome::Search.protect_filters = true
+  Awesome::Search.verbose = false
+  Awesome::Search.verbose_types = false
+  Awesome::Search.verbose_filters = false
+  Awesome::Triage.verbose = false
+  Awesome::Triage.verbose_locales = false
+
+  Awesome::Triage.configure_search_locales do |config|
+    config[:search_locales_to_classes] =
+      { ":local" =>   "Local",
+        ":amazon" =>  "Amazon",
+        ":google" =>  "Google",
+        ":ebay" =>    "Ebay" }
+    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
+
+  Awesome::Search.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
+
+  Awesome::Search.configure_search_filters do |config|
+    config[:search_filters_to_filter_modifiers] =
+      {
+        ":all" =>
+          [ ":all",
+            ":every" ],
+        ":spotted" =>
+          [ "spotted" ],
+        ":old" =>
+          [ ":old",
+            ":ancient",
+            ":wrinkly",
+            ":grey"],
+        ":new" =>
+          [ ":new",
+            ":shiny",
+            ":fresh"]
+      }
+    config[:filter_modifiers_to_search_filters] =
+      {
+        ":all"      => ":all",
+        ":every"    => ":all",
+        ":spotted"  => ":spotted",
+        ":old"      => ":old",
+        ":ancient"  => ":old",
+        ":wrinkly"  => ":old",
+        ":grey"     => ":old",
+        ":new"      => ":new",
+        ":shiny"    => ":new",
+        ":fresh"    => ":new"
+      }
+  end
+end

data/test/search_classes/amazon.rb

@@ -0,0 +1,6 @@
+class Amazon < Awesome::SuperSearch
+  def get_results
+    return nil unless super
+    nil
+  end
+end

data/test/search_classes/ebay.rb

@@ -0,0 +1,6 @@
+class Ebay < Awesome::SuperSearch
+  def get_results
+    return nil unless super
+    nil
+  end
+end

data/test/search_classes/google.rb

@@ -0,0 +1,6 @@
+class Google < Awesome::SuperSearch
+  def get_results
+    return nil unless super
+    nil
+  end
+end

data/test/search_classes/local.rb

@@ -0,0 +1,6 @@
+class Local < Awesome::SuperSearch
+  def get_results
+    return nil unless super
+    nil
+  end
+end

data/test/test_awesome_search.rb

@@ -0,0 +1,66 @@
+require 'test/helper'
+
+class TestAwesomeSearch < Test::Unit::TestCase
+
+  context "An Awesome::Search instance" do
+    setup do
+      @awesome = Awesome::Search.new({:search_text => "this is a test", :search_type => :isbn, :search_locale => :amazon})
+    end
+
+    should "return search_query" do
+      assert_equal 'this is a test', @awesome.search_query
+    end
+    should "return search_type" do
+      assert_equal :isbn, @awesome.search_type
+    end
+    should "return search_locale" do
+      assert_equal :amazon, @awesome.search_locale
+    end
+  end
+
+  context "An Awesome::Search instance with query modifiers" do
+    setup do
+      @awesome = Awesome::Search.new({:search_text => ":ebay :sku this is a test"})
+    end
+
+    should "return search_query without query modifiers" do
+      assert_equal 'this is a test', @awesome.search_query
+    end
+    should "search_type should be nil" do
+      assert_equal nil, @awesome.search_type
+    end
+    should "return search_locale" do
+      assert_equal nil, @awesome.search_locale
+    end
+  end
+
+  context "#results_for with invalid params" do
+    setup do
+      @invalid_search = Awesome::Search.results_for(":local :text this is a test", ":upc", ":ebay")
+    end
+
+    should "invalid search should return nil" do
+      assert @invalid_search.empty?
+    end
+  end
+
+  context "#results_for with valid params" do
+    setup do
+      @searches = Awesome::Search.results_for(":local :amazon :text :isbn this is a test", ":text", ":local")
+    end
+
+    should "should return an array" do
+      assert @searches.is_a?(Array)
+    end
+
+    should "for a single type, get a single result set" do
+      assert @searches.length == 1
+    end
+    should "for a single type result set has results" do
+      assert !@searches.first.found.nil?
+    end
+    should "valid search should return integer tally" do
+      assert @searches.first.tally.is_a?(Integer)
+    end
+  end
+end

data/test/test_multiple.rb

@@ -0,0 +1,24 @@
+require 'test/helper'
+
+class TestMultiple < Test::Unit::TestCase
+
+  context "#results_for with multiple types AND multiple locales" do
+    setup do
+      @searches = Awesome::Search.results_for(":local :amazon :text :isbn this is a test 1234567890", [":text",":isbn"], [":local",":amazon"])
+    end
+    should "should return an array" do
+      assert @searches.is_a?(Array)
+    end
+
+    should "returns multiple result sets" do
+      assert @searches.length > 1
+    end
+    should "all have results" do
+      assert @searches.select {|x| x.found.is_a?(Array)}.length == 4
+    end
+    should "all have tally" do
+      assert @searches.select {|x| x.tally.is_a?(Integer)}.length == 4
+    end
+  end
+
+end

data/test/test_multiple_filters.rb

@@ -0,0 +1,31 @@
+require 'test/helper'
+
+class TestMultipleFilters < Test::Unit::TestCase
+
+  context "#results_for with multiple filters" do
+    setup do
+      @searches = Awesome::Search.results_for(":local :amazon :text :isbn :old this is a test 1234567890", ":text", ":local", [":old",":spotted",":shiny",":new"])
+    end
+    should "should return an array" do
+      assert @searches.is_a?(Array)
+    end
+
+    should "returns 1 result set per type:locale combination" do
+      assert @searches.length == 1
+    end
+    should "all have results" do
+      assert @searches.select {|x| x.found.is_a?(Array)}.length == 1
+    end
+    should "all have tally" do
+      assert @searches.select {|x| x.tally.is_a?(Integer)}.length == 1
+    end
+    should "all have search_filters" do
+      assert @searches.select {|x| !x.search_filters.nil?}.length == 1
+    end
+    should "have search_filters == [':old',':spotted',':new']" do
+      #:shiny is filtered out, as it is not a filter mod for the backend, only an alias for the front end
+      assert @searches.select {|x| x.search_filters == [":old",":spotted",":new"]}.length == 1
+    end
+  end
+
+end

data/test/test_multiple_locales.rb

@@ -0,0 +1,24 @@
+require 'test/helper'
+
+class TestMultipleLocales < Test::Unit::TestCase
+
+  context "#results_for with multiple locales" do
+    setup do
+      @searches = Awesome::Search.results_for(":local :amazon :text :isbn this is a test", ":text", [":local",":amazon"])
+    end
+    should "should return an array" do
+      assert @searches.is_a?(Array)
+    end
+
+    should "returns 1 result set per type:locale combination" do
+      assert @searches.length == 2
+    end
+    should "all have results" do
+      assert @searches.select {|x| x.found.is_a?(Array)}.length == 2
+    end
+    should "all have tally" do
+      assert @searches.select {|x| x.tally.is_a?(Integer)}.length == 2
+    end
+  end
+
+end

data/test/test_multiple_types.rb

@@ -0,0 +1,42 @@
+require 'test/helper'
+
+class TestMultipleTypes < Test::Unit::TestCase
+
+  context "#results_for with multiple types as multiple types" do
+    setup do
+      @searches = Awesome::Search.results_for(":local :amazon :text :isbn this is a test 1234567890", [":text", ":isbn"], ":local")
+    end
+    should "should return an array" do
+      assert @searches.is_a?(Array)
+    end
+
+    should "returns 1 result set per type:locale combination" do
+      assert @searches.length == 2
+    end
+    should "all have results" do
+      assert @searches.select {|x| x.found.is_a?(Array)}.length == 2
+    end
+    should "all have tally" do
+      assert @searches.select {|x| x.tally.is_a?(Integer)}.length == 2
+    end
+  end
+
+  context "#results_for with multiple types as single type" do
+    setup do
+      @searches = Awesome::Search.results_for(":local :amazon :text :isbn this is a test 1234567890", [":text", ":isbn"], ":local", nil, true)
+    end
+    should "should return an array" do
+      assert @searches.is_a?(Array)
+    end
+
+    should "returns 1 result set per type:locale combination" do
+      assert @searches.length == 1
+    end
+    should "all have results" do
+      assert @searches.select {|x| x.found.is_a?(Array)}.length == 1
+    end
+    should "all have tally" do
+      assert @searches.select {|x| x.tally.is_a?(Integer)}.length == 1
+    end
+  end
+end