picky 2.7.0 → 3.0.0.pre1

data/lib/picky/query/token.rb

@@ -1,202 +1,195 @@
-module Query
+module Picky
 
-  # This is a query token. Together with other tokens it makes up a query.
-  #
-  # It remembers the original form, and and a normalized form.
-  #
-  # It also knows whether it needs to look for similarity (bla~), or whether it is a partial (bla*).
-  #
-  class Token # :nodoc:all
+  module Query
 
-    attr_reader :text, :original
-    attr_writer :similar
-
-    delegate :blank?, :to => :text
-
-    # Normal initializer.
-    #
-    # Note: Use this if you do not want a qualified and normalized token.
-    #
-    # TODO text, qualifiers
+    # This is a query token. Together with other tokens it makes up a query.
     #
-    def initialize text
-      @text = text
-    end
-
-    # Returns a qualified and normalized token.
+    # It remembers the original form, and and a normalized form.
     #
-    # Note: Use this in the search engine if you need a qualified
-    #       and normalized token. I.e. one prepared for a search.
+    # It also knows whether it needs to look for similarity (bla~), or whether it is a partial (bla*).
     #
-    def self.processed text, downcase = true
-      new(text).process downcase
-    end
-    def process downcases = true
-      qualify
-      extract_original
-      downcase if downcases
-      partialize
-      similarize
-      remove_illegals
-      symbolize
-      self
-    end
+    class Token # :nodoc:all
 
-    # This returns an array of predefined category names if the user has given any.
-    #
-    def user_defined_category_names
-      @qualifiers
-    end
-
-    # Extracts a qualifier for this token and pre-assigns an allocation.
-    #
-    # Note: Removes the qualifier if it is not allowed.
-    #
-    # TODO Extract this sind it is Search-based.
-    #
-    def qualify
-      @qualifiers, @text = split @text
-      @qualifiers && @qualifiers.collect! { |qualifier| Query::Qualifiers.instance.normalize qualifier }.compact!
-      @qualifiers
-    end
-    def extract_original
-      @original = @text.dup
-    end
+      attr_reader :text, :original, :qualifiers, :user_defined_categories
+      attr_writer :similar
 
-    # Downcases the text.
-    #
-    def downcase
-      @text.downcase!
-    end
+      delegate :blank?, :to => :text
 
-    # Partial is a conditional setter.
-    #
-    # It is only settable if it hasn't been set yet.
-    #
-    def partial= partial
-      @partial = partial if @partial.nil?
-    end
-    def partial?
-      !@similar && @partial
-    end
+      # Normal initializer.
+      #
+      # Note: Use this if you do not want a normalized token.
+      #
+      def initialize text
+        @text = text
+      end
 
-    # If the text ends with *, partialize it. If with ", don't.
-    #
-    # The latter wins. So "hello*" will not be partially searched.
-    #
-    @@no_partial = /\"\Z/
-    @@partial    = /\*\Z/
-    def partialize
-      self.partial = false and return unless @text !~ @@no_partial
-      self.partial = true unless @text !~ @@partial
-    end
+      # Returns a qualified and normalized token.
+      #
+      # Note: Use this in the search engine if you need a qualified
+      #       and normalized token. I.e. one prepared for a search.
+      #
+      def self.processed text, downcase = true
+        new(text).process downcase
+      end
+      def process downcased = true
+        qualify
+        extract_original
+        downcase if downcased
+        partialize
+        similarize
+        remove_illegals
+        symbolize
+        self
+      end
 
-    # If the text ends with ~ similarize it. If with ", don't.
-    #
-    # The latter wins.
-    #
-    @@no_similar = /\"\Z/
-    @@similar    = /\~\Z/
-    def similarize
-      self.similar = false and return if @text =~ @@no_similar
-      self.similar = true if @text =~ @@similar
-    end
+      # Translates this token's qualifiers into actual categories.
+      #
+      # Note: If this is not done, there is no mapping.
+      #
+      def categorize mapper
+        @user_defined_categories = @qualifiers && @qualifiers.map do |qualifier|
+          mapper.map qualifier
+        end.compact
+      end
 
-    def similar?
-      @similar
-    end
+      # Dups the original text.
+      #
+      def extract_original
+        @original = @text.dup
+      end
 
-    # Normalizes this token's text.
-    #
-    @@illegals = /["*~]/
-    def remove_illegals
-      @text.gsub! @@illegals, '' unless @text.blank?
-    end
+      # Downcases the text.
+      #
+      def downcase
+        @text.downcase!
+      end
 
-    #
-    #
-    def symbolize
-      @text = @text.to_sym
-    end
+      # Partial is a conditional setter.
+      #
+      # It is only settable if it hasn't been set yet.
+      #
+      def partial= partial
+        @partial = partial if @partial.nil?
+      end
+      def partial?
+        !@similar && @partial
+      end
 
-    # Returns an array of possible combinations.
-    #
-    def possible_combinations_in index
-      index.possible_combinations self
-    end
+      # If the text ends with *, partialize it. If with ", don't.
+      #
+      # The latter wins. So "hello*" will not be partially searched.
+      #
+      @@no_partial = /\"\Z/
+      @@partial    = /\*\Z/
+      def partialize
+        self.partial = false and return unless @text !~ @@no_partial
+        self.partial = true unless @text !~ @@partial
+      end
 
-    # Returns a token with the next similar text.
-    #
-    # TODO Rewrite this. It is hard to understand. Also spec performance.
-    #
-    def next_similar_token category
-      token = self.dup
-      token if token.next_similar category.bundle_for(token)
-    end
-    # Sets and returns the next similar word.
-    #
-    # Note: Also overrides the original.
-    #
-    def next_similar bundle
-      @text = @original = (similarity(bundle).shift || return) if similar?
-    end
-    # Lazy similar reader.
-    #
-    def similarity bundle = nil
-      @similarity || @similarity = generate_similarity_for(bundle)
-    end
-    # Returns an enumerator that traverses over the similar.
-    #
-    # Note: The dup isn't too nice – since it is needed on account of the shift, above.
-    #       (We avoid a StopIteration exception. Which of both is less evil?)
-    #
-    def generate_similarity_for bundle
-      bundle.similar(@text).dup || []
-    end
+      # If the text ends with ~ similarize it. If with ", don't.
+      #
+      # The latter wins.
+      #
+      @@no_similar = /\"\Z/
+      @@similar    = /\~\Z/
+      def similarize
+        self.similar = false and return if @text =~ @@no_similar
+        self.similar = true if @text =~ @@similar
+      end
 
-    #
-    #
-    def to_result
-      [@original, @text]
-    end
+      def similar?
+        @similar
+      end
 
-    # Internal identifier.
-    #
-    def identifier
-      "#{similar?? :similarity : :inverted}:#{@text}"
-    end
+      # Normalizes this token's text.
+      #
+      @@illegals = /["*~]/
+      def remove_illegals
+        @text.gsub! @@illegals, '' unless @text.blank?
+      end
 
-    # If the originals & the text are the same, they are the same.
-    #
-    def == other
-      self.original == other.original && self.text == other.text
-    end
+      #
+      #
+      def symbolize
+        @text = @text.to_sym
+      end
 
-    # Displays the qualifier text and the text, joined.
-    #
-    # e.g. name:meier
-    #
-    @@split_qualifier_text = ':'
-    @@split_qualifiers     = ','
-    def to_s
-      [@qualifiers && @qualifiers.join(@@split_qualifiers), @text].compact.join @@split_qualifier_text
-    end
+      # Returns an array of possible combinations.
+      #
+      def possible_combinations_in index
+        index.possible_combinations self
+      end
 
-    private
+      # Returns a token with the next similar text.
+      #
+      # THINK Rewrite this. It is hard to understand. Also spec performance.
+      #
+      def next_similar_token category
+        token = self.dup
+        token if token.next_similar category.bundle_for(token)
+      end
+      # Sets and returns the next similar word.
+      #
+      # Note: Also overrides the original.
+      #
+      def next_similar bundle
+        @text = @original = (similarity(bundle).shift || return) if similar?
+      end
+      # Lazy similar reader.
+      #
+      def similarity bundle = nil
+        @similarity || @similarity = generate_similarity_for(bundle)
+      end
+      # Returns an enumerator that traverses over the similar.
+      #
+      # Note: The dup isn't too nice – since it is needed on account of the shift, above.
+      #       (We avoid a StopIteration exception. Which of both is less evil?)
+      #
+      def generate_similarity_for bundle
+        bundle.similar(@text).dup || []
+      end
 
       # Splits text into a qualifier and text.
       #
-      # Returns [qualifier, text].
-      #
-      def split unqualified_text
-        qualifiers, text = (unqualified_text || '').split(@@split_qualifier_text, 2)
-        if text.blank?
-          [nil, (qualifiers || '')]
+      @@split_qualifier_text = ':'
+      @@split_qualifiers     = ','
+      def qualify
+        @qualifiers, @text = (@text || '').split(@@split_qualifier_text, 2)
+        @qualifiers, @text = if @text.blank?
+          [nil, (@qualifiers || '')]
         else
-          [qualifiers.split(@@split_qualifiers), text]
+          [@qualifiers.split(@@split_qualifiers), @text]
         end
       end
 
+      #
+      #
+      def to_result
+        [@original, @text]
+      end
+
+      # Internal identifier.
+      #
+      def identifier
+        "#{similar?? :similarity : :inverted}:#{@text}"
+      end
+
+      # If the originals & the text are the same, they are the same.
+      #
+      def == other
+        self.original == other.original && self.text == other.text
+      end
+
+      # Displays the text and the qualifiers.
+      #
+      # e.g. name:meier
+      #
+      def to_s
+        "#{self.class}(#{[@text, (@qualifiers.inspect unless @qualifiers.blank?)].compact.join(', ')})"
+      end
+
+    end
+
   end
 
 end

data/lib/picky/query/tokens.rb

@@ -1,101 +1,105 @@
-# encoding: utf-8
-#
-module Query
+module Picky
 
-  # This class primarily handles switching through similar token constellations.
+  # encoding: utf-8
   #
-  class Tokens # :nodoc:all
+  module Query
 
-    # Basically delegates to its internal tokens array.
+    # This class primarily handles switching through similar token constellations.
     #
-    self.delegate *[Enumerable.instance_methods, :slice!, :[], :uniq!, :last, :reject!, :length, :size, :empty?, :each, :exit, { :to => :@tokens }].flatten
+    class Tokens # :nodoc:all
 
-    # Create a new Tokens object with the array of tokens passed in.
-    #
-    def initialize tokens = []
-      @tokens = tokens
-    end
+      # Basically delegates to its internal tokens array.
+      #
+      self.delegate *[Enumerable.instance_methods, :slice!, :[], :uniq!, :last, :reject!, :length, :size, :empty?, :each, :exit, { :to => :@tokens }].flatten
 
-    # Creates a new Tokens object from a number of Strings.
-    #
-    # Options:
-    #  * downcase: Whether to downcase the passed strings (default is true)
-    #
-    def self.processed words, downcase = true
-      new words.collect! { |word| Token.processed word, downcase }
-    end
+      # Create a new Tokens object with the array of tokens passed in.
+      #
+      def initialize tokens = []
+        @tokens = tokens
+      end
 
-    # Tokenizes each token.
-    #
-    # Note: Passed tokenizer needs to offer #normalize(text).
-    #
-    def tokenize_with tokenizer
-      @tokens.each { |token| token.tokenize_with(tokenizer) }
-    end
+      # Creates a new Tokens object from a number of Strings.
+      #
+      # Options:
+      #  * downcase: Whether to downcase the passed strings (default is true)
+      #
+      def self.processed words, downcase = true
+        new words.collect! { |word| Token.processed word, downcase }
+      end
 
-    # Generates an array in the form of
-    # [
-    #  [combination],                           # of token 1
-    #  [combination, combination, combination], # of token 2
-    #  [combination, combination]               # of token 3
-    # ]
-    #
-    def possible_combinations_in index
-      @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
+      # Tokenizes each token.
+      #
+      # Note: Passed tokenizer needs to offer #normalize(text).
+      #
+      def tokenize_with tokenizer
+        @tokens.each { |token| token.tokenize_with(tokenizer) }
       end
-    end
 
-    # Makes the last of the tokens partial.
-    #
-    def partialize_last
-      @tokens.last.partial = true unless empty?
-    end
+      # Generates an array in the form of
+      # [
+      #  [combination],                           # of token 1
+      #  [combination, combination, combination], # of token 2
+      #  [combination, combination]               # of token 3
+      # ]
+      #
+      def possible_combinations_in index
+        @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
+        end
+      end
 
-    # Caps the tokens to the maximum.
-    #
-    def cap maximum
-      @tokens.slice!(maximum..-1) if cap?(maximum)
-    end
-    def cap? maximum
-      @tokens.size > maximum
-    end
+      # Makes the last of the tokens partial.
+      #
+      def partialize_last
+        @tokens.last.partial = true unless empty?
+      end
 
-    # Rejects blank tokens.
-    #
-    def reject
-      @tokens.reject! &:blank?
-    end
+      # Caps the tokens to the maximum.
+      #
+      def cap maximum
+        @tokens.slice!(maximum..-1) if cap?(maximum)
+      end
+      def cap? maximum
+        @tokens.size > maximum
+      end
 
-    # Returns a solr query.
-    #
-    def to_solr_query
-      @tokens.map(&:to_solr).join ' '
-    end
+      # Rejects blank tokens.
+      #
+      def reject
+        @tokens.reject! &:blank?
+      end
 
-    #
-    #
-    def originals
-      @tokens.map(&:original)
-    end
+      #
+      #
+      def categorize mapper
+        @tokens.each { |token| token.categorize mapper }
+      end
 
-    def == other
-      self.tokens == other.tokens
-    end
+      #
+      #
+      def originals
+        @tokens.map(&:original)
+      end
+
+      def == other
+        self.tokens == other.tokens
+      end
+
+      # Just join the token original texts.
+      #
+      def to_s
+        originals.join ' '
+      end
 
-    # Just join the token original texts.
-    #
-    def to_s
-      originals.join ' '
     end
 
   end

data/lib/picky/query/weights.rb

@@ -1,62 +1,58 @@
-module Query
+module Picky
 
-  # Calculates weights for certain combinations.
-  #
-  class Weights # :nodoc:all
+  module Query
 
-    attr_reader :weights
-
-    #
+    # Calculates weights for certain combinations.
     #
-    def initialize weights = {}
-      @weights = weights
-    end
+    class Weights # :nodoc:all
 
-    # Get the weight of an allocation.
-    #
-    def weight_for clustered
-      @weights[clustered] || 0
-    end
+      attr_reader :weights
+
+      delegate :empty?, :to => :weights
 
-    # Returns an energy term E for allocation. this turns into a probability
-    # by P(allocation) = 1/Z * exp (-1/T * E(allocation)),
-    # where Z is the normalizing partition function
-    # sum_allocations exp(-1/T *E(allocation)), and T is a temperature constant.
-    # If T is high the distribution will be close to equally distributed.
-    # If T is low, the distribution will be the indicator function
-    # for min (E(allocation))…
-    #
-    # ...
-    #
-    # Just kidding. It's far more complicated than that. Ha ha ha ha ;)
-    #
-    # Note: Cache this if more complicated weighings become necessary.
-    #
-    def score combinations
-      # TODO Or hide: combinations#to_weights_key (but it's an array, so…)
       #
-      # TODO combinations could cluster uniq as combinations are added (since combinations don't change).
       #
-      # TODO Or it could use actual combinations? Could it? Or make combinations comparable to Symbols.
+      def initialize weights = {}
+        @weights = weights
+      end
+
+      # Get the weight of an allocation.
       #
-      weight_for combinations.map(&:category_name).clustered_uniq_fast
-    end
+      def weight_for clustered
+        @weights[clustered] || 0
+      end
+
+      # Returns an energy term E for allocation. this turns into a probability
+      # by P(allocation) = 1/Z * exp (-1/T * E(allocation)),
+      # where Z is the normalizing partition function
+      # sum_allocations exp(-1/T *E(allocation)), and T is a temperature constant.
+      # If T is high the distribution will be close to equally distributed.
+      # If T is low, the distribution will be the indicator function
+      # for min (E(allocation))…
+      #
+      # ...
+      #
+      # Just kidding. It's far more complicated than that. Ha ha ha ha ;)
+      #
+      # Note: Cache this if more complicated weighings become necessary.
+      #
+      def score combinations
+        # TODO Or it could use actual combinations? Could it? Or make combinations comparable to Symbols.
+        #
+        weight_for combinations.map(&:category_name).clustered_uniq_fast
+      end
 
-    # Are there any weights defined?
-    #
-    def empty?
-      @weights.empty?
-    end
+      def == other
+        @weights == other.weights
+      end
 
-    def == other
-      @weights == other.weights
-    end
+      # Prints out a nice representation of the configured weights.
+      #
+      def to_s
+        "#{self.class}(#{@weights})"
+      end
 
-    # Prints out a nice representation of the configured weights.
-    #
-    def to_s
-      @weights.to_s
     end
-
   end
+
 end

data/lib/picky/query.rb

@@ -1,2 +1,6 @@
-module Query # :nodoc:all
+module Picky
+
+  module Query # :nodoc:all
+  end
+
 end