picky 3.1.4 → 3.1.5

data/lib/picky/categories.rb

@@ -15,23 +15,8 @@ module Picky
 
     # A list of indexed categories.
     #
-    # Options:
-    #  * ignore_unassigned_tokens: Ignore the given token if it cannot be matched to a category.
-    #                              The default behaviour is that if a token does not match to
-    #                              any category, the query will not return anything (since a
-    #                              single token cannot be matched). If you set this option to
-    #                              true, any token that cannot be matched to a category will be
-    #                              simply ignored.
-    #                              Use this if only a few matched words are important, like for
-    #                              example of the query "Jonathan Myers 86455 Las Cucarachas"
-    #                              you only want to match the zipcode, to have the search engine
-    #                              display advertisements on the side for the zipcode.
-    #                              Nifty! :)
-    #
     def initialize options = {}
       clear_categories
-
-      @ignore_unassigned_tokens = options[:ignore_unassigned_tokens] || false
     end
 
     # Clears both the array of categories and the hash of categories.

data/lib/picky/categories_indexed.rb

@@ -2,8 +2,6 @@ module Picky
 
   class Categories
 
-    attr_reader :ignore_unassigned_tokens
-
     each_delegate :load_from_cache,
                   :analyze,
                   :to => :categories
@@ -56,20 +54,13 @@ module Picky
     # Returns possible Combinations for the token.
     #
     # Note: The preselected_categories param is an optimization.
-    #
     # Note: Returns [] if no categories matched (will produce no result).
-    #       Returns nil if this token needs to be removed from the query.
-    #       (Also none of the categories matched, but the ignore unassigned
-    #       tokens option is true)
     #
     def possible_for token, preselected_categories = nil
       possible = (preselected_categories || possible_categories(token)).inject([]) do |combinations, category|
         combination = category.combination_for token
         combination ? combinations << combination : combinations
       end
-      # This is an optimization to mark tokens that are ignored.
-      #
-      return if ignore_unassigned_tokens && possible.empty?
       possible
     end
 

data/lib/picky/index.rb

@@ -98,7 +98,7 @@ module Picky
     # === Parameters
     # * name: A name that will be used for the index directory and in the Picky front end.
     #
-    # === Options (all are used in the block, see examples)
+    # === Options (all are used in the block - not passed as a Hash, see examples)
     # * source: Where the data comes from, e.g. Sources::CSV.new(...). Optional, can be defined in the block using #source.
     # * result_identifier: Use if you'd like a different identifier/name in the results than the name of the index.
     # * after_indexing: As of this writing only used in the db source. Executes the given after_indexing as SQL after the indexing process.
@@ -113,12 +113,9 @@ module Picky
     #     result_identifier :my_special_results
     #   end
     #
-    def initialize name, options = {}
-      @name              = name.to_sym
-
-      # TODO Move ignore_unassigned_tokens to query, somehow. Then, remove options.
-      #
-      @categories = Categories.new ignore_unassigned_tokens: (options[:ignore_unassigned_tokens] || false)
+    def initialize name
+      @name       = name.to_sym
+      @categories = Categories.new
 
       # Centralized registry.
       #

data/lib/picky/query/tokens.rb

@@ -8,20 +8,23 @@ module Picky
     #
     class Tokens # :nodoc:all
 
+      attr_reader :ignore_unassigned
+
       # Basically delegates to its internal tokens array.
       #
       self.delegate *[Enumerable.instance_methods, :slice!, :[], :uniq!, :last, :reject!, :length, :size, :empty?, :each, :exit, { :to => :@tokens }].flatten
 
       # Create a new Tokens object with the array of tokens passed in.
       #
-      def initialize tokens = []
-        @tokens = tokens
+      def initialize tokens, ignore_unassigned = false
+        @tokens            = tokens
+        @ignore_unassigned = ignore_unassigned
       end
 
       # Creates a new Tokens object from a number of Strings.
       #
-      def self.processed words, originals
-        new words.zip(originals).collect! { |word, original| Token.processed word, original }
+      def self.processed words, originals, ignore_unassigned = false
+        new words.zip(originals).collect! { |word, original| Token.processed word, original }, ignore_unassigned
       end
 
       # Tokenizes each token.
@@ -45,14 +48,16 @@ module Picky
         @tokens.inject([]) do |combinations, token|
           possible_combinations = token.possible_combinations_in index
 
-          # TODO Could move the ignore_unassigned_tokens here!
-          #
           # Note: Optimization for ignoring tokens that allocate to nothing and
           # can be ignored.
           # For example in a special search, where "florian" is not
           # mapped to any category.
           #
-          possible_combinations ? combinations << possible_combinations : combinations
+          if ignore_unassigned && possible_combinations.empty?
+            combinations
+          else
+            combinations << possible_combinations
+          end
         end
       end
 

data/lib/picky/search.rb

@@ -44,6 +44,7 @@ module Picky
 
       @tokenizer ||= Tokenizer.query_default # THINK Not dynamic. Ok?
       @weights   ||= Query::Weights.new
+      @ignore_unassigned = false if @ignore_unassigned.nil?
 
       self
     end
@@ -99,6 +100,33 @@ module Picky
       end
     end
 
+    # Ignore the given token if it cannot be matched to a category.
+    # The default behaviour is that if a token does not match to
+    # any category, the query will not return anything (since a
+    # single token cannot be matched). If you set this option to
+    # true, any token that cannot be matched to a category will be
+    # simply ignored.
+    #
+    # Use this if only a few matched words are important, like for
+    # example of the query "Jonathan Myers 86455 Las Cucarachas"
+    # you only want to match the zipcode, to have the search engine
+    # display advertisements on the side for the zipcode.
+    #
+    # False by default.
+    #
+    # Example:
+    #   search = Search.new(books_index, dvd_index, mp3_index) do
+    #     ignore_unassigned_tokens true
+    #   end
+    #
+    # With this set to true, if in "Peter Flunder", "Flunder"
+    # couldn't be assigned to any category, it will simply be
+    # ignored. This is done for each categorization.
+    #
+    def ignore_unassigned_tokens value
+      @ignore_unassigned = value
+    end
+
     # This is the main entry point for a query.
     # Use this in specs and also for running queries.
     #
@@ -146,7 +174,7 @@ module Picky
     #
     def tokenized text
       tokens, originals = tokenizer.tokenize text
-      tokens = Query::Tokens.processed tokens, originals || tokens
+      tokens = Query::Tokens.processed tokens, originals || tokens, @ignore_unassigned
       tokens.partialize_last # Note: In the standard Picky search, the last token is always partial.
       tokens
     end

data/spec/lib/categories_indexed_spec.rb

@@ -1,24 +1,6 @@
 require 'spec_helper'
 
 describe Picky::Categories do
-  context 'with option ignore_unassigned_tokens' do
-    context 'ignore_unassigned_tokens true' do
-      before(:each) do
-        @categories = described_class.new ignore_unassigned_tokens: true
-      end
-      it 'should return the right value' do
-        @categories.ignore_unassigned_tokens.should == true
-      end
-    end
-    context 'ignore_unassigned_tokens false' do
-      before(:each) do
-        @categories = described_class.new ignore_unassigned_tokens: false
-      end
-      it 'should return the right value' do
-        @categories.ignore_unassigned_tokens.should == false
-      end
-    end
-  end
   
   context "with real categories" do
     before(:each) do

data/spec/lib/query/tokens_spec.rb

@@ -2,6 +2,53 @@ require 'spec_helper'
 
 describe Picky::Query::Tokens do
   
+  context 'with ignore_unassigned_tokens true' do
+    it 'generates processed tokens from all words' do
+      expected = [
+        Picky::Query::Token.processed('this~'),
+        Picky::Query::Token.processed('is'),
+        Picky::Query::Token.processed('a'),
+        Picky::Query::Token.processed('sp:solr'),
+        Picky::Query::Token.processed('query"')
+      ]
+      
+      described_class.should_receive(:new).once.with expected, true
+      
+      described_class.processed ['this~', 'is', 'a', 'sp:solr', 'query"'], [], true
+    end
+    
+    describe 'possible_combinations_in' do
+      before(:each) do
+        @token1 = stub :token1
+        @token2 = stub :token2
+        @token3 = stub :token3
+
+        @tokens = described_class.new [@token1, @token2, @token3], true
+      end
+      it 'should work correctly' do
+        @token1.should_receive(:possible_combinations_in).once.with(:some_index).and_return [:combination11, :combination12]
+        @token2.should_receive(:possible_combinations_in).once.with(:some_index).and_return [:combination21]
+        @token3.should_receive(:possible_combinations_in).once.with(:some_index).and_return [:combination31, :combination32, :combination33]
+
+        @tokens.possible_combinations_in(:some_index).should == [
+          [:combination11, :combination12],
+          [:combination21],
+          [:combination31, :combination32, :combination33]
+        ]
+      end
+      it 'should work correctly' do
+        @token1.should_receive(:possible_combinations_in).once.with(:some_index).and_return [:combination11, :combination12]
+        @token2.should_receive(:possible_combinations_in).once.with(:some_index).and_return []
+        @token3.should_receive(:possible_combinations_in).once.with(:some_index).and_return [:combination31, :combination32, :combination33]
+
+        @tokens.possible_combinations_in(:some_index).should == [
+          [:combination11, :combination12],
+          [:combination31, :combination32, :combination33]
+        ]
+      end
+    end
+  end
+  
   describe '.processed' do
     it 'generates processed tokens from all words' do
       expected = [
@@ -12,7 +59,7 @@ describe Picky::Query::Tokens do
         Picky::Query::Token.processed('query"')
       ]
       
-      described_class.should_receive(:new).once.with expected
+      described_class.should_receive(:new).once.with expected, false
       
       described_class.processed ['this~', 'is', 'a', 'sp:solr', 'query"'], []
     end
@@ -25,7 +72,7 @@ describe Picky::Query::Tokens do
         Picky::Query::Token.processed('query"')
       ]
       
-      described_class.should_receive(:new).once.with expected
+      described_class.should_receive(:new).once.with expected, false
       
       described_class.processed ['this~', 'is', 'a', 'sp:solr', 'query"'], []
     end
@@ -114,6 +161,7 @@ describe Picky::Query::Tokens do
 
       @tokens.possible_combinations_in(:some_index).should == [
         [:combination11, :combination12],
+        nil,
         [:combination31, :combination32, :combination33]
       ]
     end

metadata

@@ -2,7 +2,7 @@
 name: picky
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 3.1.4
+  version: 3.1.5
 platform: ruby
 authors: 
 - Florian Hanke
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-02 00:00:00 +02:00
+date: 2011-09-04 00:00:00 +02:00
 default_executable: picky
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,7 +32,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 3.1.4
+        version: 3.1.5
   type: :development
   version_requirements: *id002
 description: Fast Ruby semantic text search engine with comfortable single field interface.