picky 2.7.0 → 3.0.0.pre1

data/lib/picky/categories.rb

@@ -1,63 +1,67 @@
-class Categories
-
-  attr_reader :categories, :category_hash
-
-  delegate :each,
-           :first,
-           :map,
-           :to => :categories
-
-  each_delegate :reindex,
-                :each_category,
-                :to => :categories
-
-  # 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
+module Picky
 
-  # Clears both the array of categories and the hash of categories.
-  #
-  def clear_categories
-    @categories    = []
-    @category_hash = {}
-  end
+  class Categories
 
-  # Add the given category to the list of categories.
-  #
-  def << category
-    categories << category
-    category_hash[category.name] = category
-  end
+    attr_reader :categories, :category_hash
 
-  # Find a given category in the categories.
-  #
-  def [] category_name
-    category_name = category_name.to_sym
-    category_hash[category_name] || raise_not_found(category_name)
-  end
-  def raise_not_found category_name
-    raise %Q{Index category "#{category_name}" not found. Possible categories: "#{categories.map(&:name).join('", "')}".}
-  end
+    delegate :each,
+             :first,
+             :map,
+             :to => :categories
+
+    each_delegate :reindex,
+                  :each_category,
+                  :to => :categories
+
+    # 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.
+    #
+    def clear_categories
+      @categories    = []
+      @category_hash = {}
+    end
+
+    # Add the given category to the list of categories.
+    #
+    def << category
+      categories << category
+      category_hash[category.name] = category
+    end
+
+    # Find a given category in the categories.
+    #
+    def [] category_name
+      category_name = category_name.to_sym
+      category_hash[category_name] || raise_not_found(category_name)
+    end
+    def raise_not_found category_name
+      raise %Q{Index category "#{category_name}" not found. Possible categories: "#{categories.map(&:name).join('", "')}".}
+    end
+
+    def to_s
+      categories.join(', ')
+    end
 
-  def to_s
-    categories.join(', ')
   end
 
 end

data/lib/picky/categories_indexed.rb

@@ -1,98 +1,89 @@
-class Categories
+module Picky
 
-  attr_reader :ignore_unassigned_tokens
+  class Categories
 
-  each_delegate :load_from_cache,
-                :analyze,
-                :to => :categories
+    attr_reader :ignore_unassigned_tokens
 
-  # Return all possible combinations for the given token.
-  #
-  # This checks if it needs to also search through similar
-  # tokens, if for example, the token is one with ~.
-  # If yes, it puts together all solutions.
-  #
-  def possible_combinations_for token
-    token.similar? ? similar_possible_for(token) : possible_for(token)
-  end
+    each_delegate :load_from_cache,
+                  :analyze,
+                  :to => :categories
 
-  # Gets all similar tokens and puts together the possible combinations
-  # for each found similar token.
-  #
-  def similar_possible_for token
-    tokens = similar_tokens_for token
-    inject_possible_for tokens
-  end
+    # Return all possible combinations for the given token.
+    #
+    # This checks if it needs to also search through similar
+    # tokens, if for example, the token is one with ~.
+    # If yes, it puts together all solutions.
+    #
+    def possible_combinations token
+      token.similar? ? similar_possible_for(token) : possible_for(token)
+    end
 
-  # Returns all possible similar tokens for the given token.
-  #
-  def similar_tokens_for token
-    text = token.text
-    categories.inject([]) do |result, category|
-      next_token = token
-      # Note: We could also break off here if not all the available
-      #       similars are needed.
-      #       Wait for a concrete case that needs this before taking
-      #       action.
-      #
-      while next_token = next_token.next_similar_token(category)
-        result << next_token if next_token && next_token.text != text
-      end
-      result
+    # Gets all similar tokens and puts together the possible combinations
+    # for each found similar token.
+    #
+    def similar_possible_for token
+      tokens = similar_tokens_for token
+      inject_possible_for tokens
     end
-  end
 
-  #
-  #
-  def inject_possible_for tokens
-    tokens.inject([]) do |result, token|
-      possible = possible_categories token
-      result + possible_for(token, possible)
+    # Returns all possible similar tokens for the given token.
+    #
+    def similar_tokens_for token
+      text = token.text
+      categories.inject([]) do |result, category|
+        next_token = token
+        # Note: We could also break off here if not all the available
+        #       similars are needed.
+        #       Wait for a concrete case that needs this before taking
+        #       action.
+        #
+        while next_token = next_token.next_similar_token(category)
+          result << next_token if next_token && next_token.text != text
+        end
+        result
+      end
     end
-  end
 
-  # 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
+    #
+    #
+    def inject_possible_for tokens
+      tokens.inject([]) do |result, token|
+        possible = possible_categories token
+        result + possible_for(token, possible)
+      end
     end
-    # This is an optimization to mark tokens that are ignored.
+
+    # Returns possible Combinations for the token.
     #
-    return if ignore_unassigned_tokens && possible.empty?
-    possible
-  end
+    # 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
 
-  # This returns the possible categories for this token.
-  # If the user has already preselected a category for this token,
-  # like "artist:moby", if not just return all for the given token,
-  # since all are possible.
-  #
-  # Note: Once I thought this was called too often. But it is not (18.01.2011).
-  #
-  def possible_categories token
-    user_defined_categories(token) || categories
-  end
+    # This returns the possible categories for this token.
+    # If the user has already preselected a category for this token,
+    # like "artist:moby", if not just return all for the given token,
+    # since all are possible.
+    #
+    # Note: Once I thought this was called too often. But it is not (18.01.2011).
+    #
+    def possible_categories token
+      token.user_defined_categories || categories
+    end
 
-  # This returns the array of categories if the user has defined
-  # an existing category.
-  #
-  # Note: Returns nil if the user did not define one
-  #       or [] if he/she has defined a non-existing one.
-  #
-  def user_defined_categories token
-    names = token.user_defined_category_names
-    names && names.map do |name|
-      category_hash[name]
-    end.compact
   end
 
 end

data/lib/picky/categories_indexing.rb

@@ -1,10 +1,14 @@
-class Categories
-
-  each_delegate :cache,
-                :check,
-                :clear,
-                :backup,
-                :restore,
-                :to => :categories
+module Picky
+
+  class Categories
+
+    each_delegate :cache,
+                  :check,
+                  :clear,
+                  :backup,
+                  :restore,
+                  :to => :categories
+
+  end
 
 end

data/lib/picky/category.rb

@@ -1,139 +1,128 @@
-class Category
+module Picky
 
-  attr_reader :name
+  class Category
 
-  # Mandatory params:
-  #  * name: Category name to use as identifier and file names.
-  #  * index: Index to which this category is attached to.
-  #
-  # Options:
-  #  * partial: Partial::None.new, Partial::Substring.new(from:start_char, to:up_to_char) (defaults from:-3, to:-1)
-  #  * similarity: Similarity::None.new (default), Similarity::DoubleMetaphone.new(amount_of_similarly_linked_words)
-  #  * from: The source category identifier to take the data from.
-  #
-  # Advanced Options:
-  #  * source: Use if the category should use a different source.
-  #  * weights: Query::Weights.new( [:category1, :category2] => +2, ... )
-  #  * tokenizer: Use a subclass of Tokenizers::Base that implements #tokens_for and #empty_tokens.
-  #  * key_format: What this category's keys are formatted with (default is :to_i)
-  #
-  def initialize name, index, options = {}
-    @name  = name
-    @index = index
+    attr_reader :name
 
-    # Indexing.
+    # Mandatory params:
+    #  * name: Category name to use as identifier and file names.
+    #  * index: Index to which this category is attached to.
     #
-    @source     = options[:source]
-    @from       = options[:from]
-    @tokenizer  = options[:tokenizer]
-    @key_format = options[:key_format]
-
-    # TODO Push into Bundle. At least the weights.
+    # Options:
+    #  * partial: Partial::None.new, Partial::Substring.new(from:start_char, to:up_to_char) (defaults from:-3, to:-1)
+    #  * similarity: Similarity::None.new (default), Similarity::DoubleMetaphone.new(amount_of_similarly_linked_words)
+    #  * from: The source category identifier to take the data from.
     #
-    weights    = options[:weights]    || Generators::Weights::Default
-    partial    = options[:partial]    || Generators::Partial::Default
-    similarity = options[:similarity] || Generators::Similarity::Default
-
-    @indexing_exact   = index.indexing_bundle_class.new(:exact,   self, weights, Generators::Partial::None.new, similarity)
-    @indexing_partial = index.indexing_bundle_class.new(:partial, self, weights, partial, Generators::Similarity::None.new)
-
-    # Indexed.
+    # Advanced Options:
+    #  * source: Use if the category should use a different source.
+    #  * weights: Query::Weights.new( [:category1, :category2] => +2, ... )
+    #  * tokenizer: Use a subclass of Tokenizers::Base that implements #tokens_for and #empty_tokens.
+    #  * key_format: What this category's keys are formatted with (default is :to_i)
     #
-    # TODO Push the defaults out into the index.
+    def initialize name, index, options = {}
+      @name  = name
+      @index = index
+
+      # Indexing.
+      #
+      @source     = options[:source]
+      @from       = options[:from]
+      @tokenizer  = options[:tokenizer]
+      @key_format = options[:key_format]
+      @qualifiers = extract_qualifiers_from options
+
+      weights    = options[:weights]    || Generators::Weights::Default
+      partial    = options[:partial]    || Generators::Partial::Default
+      similarity = options[:similarity] || Generators::Similarity::Default
+
+      @indexing_exact   = index.indexing_bundle_class.new :exact,   self, weights, Generators::Partial::None.new, similarity, options
+      @indexing_partial = index.indexing_bundle_class.new :partial, self, weights, partial, Generators::Similarity::None.new, options
+
+      # Indexed.
+      #
+      @indexed_exact  = index.indexed_bundle_class.new  :exact, self, similarity
+      if partial.use_exact_for_partial?
+        @indexed_partial  = @indexed_exact
+      else
+        @indexed_partial  = index.indexed_bundle_class.new  :partial, self, similarity
+      end
+
+      # @exact   = exact_lambda.call(@exact, @partial)   if exact_lambda   = options[:exact_lambda]
+      # @partial = partial_lambda.call(@exact, @partial) if partial_lambda = options[:partial_lambda]
+    end
+
+    # Indexes and reloads the category.
     #
-    @partial_strategy = partial # TODO Duplicate work.
-
-    @indexed_exact   = index.indexed_bundle_class.new :exact,   self, similarity
-    @indexed_partial = index.indexed_bundle_class.new :partial, self, similarity
-
-    # @exact   = exact_lambda.call(@exact, @partial)   if exact_lambda   = options[:exact_lambda]
-    # @partial = partial_lambda.call(@exact, @partial) if partial_lambda = options[:partial_lambda]
+    def reindex
+      index
+      reload
+    end
 
-    # TODO Extract? Yes.
+    # Index name.
     #
-    Query::Qualifiers.add(name, generate_qualifiers_from(options) || [name])
-  end
-
-  # TODO Move to Index.
-  #
-  def generate_qualifiers_from options
-    options[:qualifiers] || options[:qualifier] && [options[:qualifier]]
-  end
+    def index_name
+      @index.name
+    end
 
-  # Indexes and reloads the category.
-  #
-  def reindex
-    index
-    reload
-  end
-
-  # Category name.
-  #
-  def category_name
-    name
-  end
-
-  # Index name.
-  #
-  def index_name
-    @index.name
-  end
+    # Returns the qualifiers if set or
+    # just the name if not.
+    #
+    def qualifiers
+      @qualifiers || [name]
+    end
+    # Extract qualifiers from the options.
+    #
+    def extract_qualifiers_from options
+      options[:qualifiers] || options[:qualifier] && [options[:qualifier]]
+    end
 
-  # The category itself just yields itself.
-  #
-  def each_category
-    yield self
-  end
+    # The category itself just yields itself.
+    #
+    def each_category
+      yield self
+    end
 
-  # Path and partial filename of the prepared index on this category.
-  #
-  def prepared_index_path
-    @prepared_index_path ||= "#{index_directory}/prepared_#{name}_index"
-  end
-  # Get an opened index file.
-  #
-  # Note: If you don't use it with the block, do not forget to close it.
-  #
-  def prepared_index_file &block
-    @prepared_index_file ||= Backend::File::Text.new prepared_index_path
-    @prepared_index_file.open &block
-  end
-  # Creates the index directory including all necessary paths above it.
-  #
-  # Note: Interface method called by any indexers.
-  #
-  def prepare_index_directory
-    FileUtils.mkdir_p index_directory
-  end
+    # Path and partial filename of the prepared index on this category.
+    #
+    def prepared_index_path
+      @prepared_index_path ||= "#{index_directory}/prepared_#{name}_index"
+    end
+    # Get an opened index file.
+    #
+    # Note: If you don't use it with the block, do not forget to close it.
+    #
+    def prepared_index_file &block
+      @prepared_index_file ||= Backend::File::Text.new prepared_index_path
+      @prepared_index_file.open &block
+    end
+    # Creates the index directory including all necessary paths above it.
+    #
+    # Note: Interface method called by any indexers.
+    #
+    def prepare_index_directory
+      FileUtils.mkdir_p index_directory
+    end
 
-  # The index directory for this category.
-  #
-  def index_directory
-    @index_directory ||= "#{PICKY_ROOT}/index/#{PICKY_ENVIRONMENT}/#{@index.name}"
-  end
+    # The index directory for this category.
+    #
+    # TODO Push down into files?
+    #
+    def index_directory
+      @index_directory ||= "#{PICKY_ROOT}/index/#{PICKY_ENVIRONMENT}/#{@index.name}"
+    end
 
-  # Path and partial filename of a specific subindex on this category.
-  #
-  # Subindexes are:
-  #  * inverted index
-  #  * weights index
-  #  * partial index
-  #  * similarity index
-  #
-  def index_path bundle_name, type
-    "#{index_directory}/#{name}_#{bundle_name}_#{type}"
-  end
+    # Identifier for technical output.
+    #
+    def identifier
+      "#{@index.identifier}:#{name}"
+    end
 
-  # Identifier for technical output.
-  #
-  def identifier
-    @identifier ||= "#{PICKY_ENVIRONMENT}:#{index_name}:#{name}"
-  end
+    #
+    #
+    def to_s
+      "#{self.class}(#{identifier})"
+    end
 
-  #
-  #
-  def to_s
-    "Category(#{name})"
   end
 
 end

data/lib/picky/category_indexed.rb

@@ -1,48 +1,46 @@
-#
-#
-class Category
+module Picky
 
-  attr_reader :indexed_exact
-
-  # Loads the index from cache.
-  #
-  def load_from_cache
-    timed_exclaim %Q{"#{identifier}": Loading index from cache.}
-    indexed_exact.load
-    indexed_partial.load
-  end
-  alias reload load_from_cache
-
-  # Gets the weight for this token's text.
-  #
-  def weight token
-    bundle_for(token).weight token.text
-  end
-
-  # Gets the ids for this token's text.
   #
-  def ids token
-    bundle_for(token).ids token.text
-  end
-
-  # Returns the right index bundle for this token.
   #
-  def bundle_for token
-    token.partial? ? indexed_partial : indexed_exact
-  end
+  class Category
+
+    attr_reader :indexed_exact,
+                :indexed_partial
+
+    # Loads the index from cache.
+    #
+    def load_from_cache
+      timed_exclaim %Q{"#{identifier}": Loading index from cache.}
+      indexed_exact.load
+      indexed_partial.load
+    end
+    alias reload load_from_cache
+
+    # Gets the weight for this token's text.
+    #
+    def weight token
+      bundle_for(token).weight token.text
+    end
+
+    # Gets the ids for this token's text.
+    #
+    def ids token
+      bundle_for(token).ids token.text
+    end
+
+    # Returns the right index bundle for this token.
+    #
+    def bundle_for token
+      token.partial? ? indexed_partial : indexed_exact
+    end
+
+    # Returns a combination for the token,
+    # or nil, if there is none.
+    #
+    def combination_for token
+      weight(token) && Query::Combination.new(token, self)
+    end
 
-  # The partial strategy defines whether to
-  # really use the partial index.
-  #
-  def indexed_partial
-    @partial_strategy.use_exact_for_partial? ? @indexed_exact : @indexed_partial
-  end
-
-  # Returns a combination for the token,
-  # or nil, if there is none.
-  #
-  def combination_for token
-    weight(token) && Query::Combination.new(token, self)
   end
 
 end