picky 1.4.1 → 1.4.2

data/lib/picky/query/allocations.rb

@@ -1,130 +0,0 @@
-module Query
-  # Container class for allocations.
-  #
-  class Allocations # :nodoc:all
-
-    # TODO Remove size
-    #
-    delegate :each, :inject, :empty?, :size, :to => :@allocations
-    attr_reader :total
-
-    def initialize allocations = []
-      @allocations = allocations
-    end
-
-    # Score each allocation.
-    #
-    def calculate_score weights
-      @allocations.each do |allocation|
-        allocation.calculate_score weights
-      end
-    end
-    # Sort the allocations.
-    #
-    def sort
-      @allocations.sort!
-    end
-
-    # Reduces the amount of allocations to x.
-    #
-    def reduce_to amount
-      @allocations = @allocations.shift amount
-    end
-
-    # Keeps combinations.
-    #
-    # Only those passed in remain.
-    #
-    def keep identifiers = []
-      @allocations.each { |allocation| allocation.keep identifiers } unless identifiers.empty?
-    end
-    # Removes combinations.
-    #
-    # Only those passed in are removed.
-    #
-    # TODO Rewrite
-    #
-    def remove identifiers = []
-      @allocations.each { |allocation| allocation.remove identifiers } unless identifiers.empty?
-    end
-
-    # Returns the top amount ids.
-    #
-    def ids amount = 20
-      @allocations.inject([]) do |total, allocation|
-        total.size >= amount ? (return total.shift(amount)) : total + allocation.ids
-      end
-    end
-
-    # Returns a random id from the allocations.
-    #
-    # Note: This is an ok algorithm for small id sets.
-    #
-    # But still TODO try for a faster one.
-    #
-    def random_ids amount = 1
-      return [] if @allocations.empty?
-      ids = @allocations.first.ids
-      indexes = Array.new(ids.size) { |id| id }.sort_by { rand }
-      indexes.first(amount).map { |id| ids[id] }
-    end
-
-    # This is the main method of this class that will replace ids and count.
-    #
-    # What it does is calculate the ids and counts of its allocations
-    # for being used in the results. It also calculates the total
-    #
-    # Parameters:
-    #  * amount: the amount of ids to calculate
-    #  * offset: the offset from where in the result set to take the ids
-    #
-    # Note: With an amount of 0, an offset > 0 doesn't make much
-    #       sense, as seen in the live search.
-    #
-    # Note: Each allocation caches its count, but not its ids (thrown away).
-    #       The ids are cached in this class.
-    #
-    # Note: It's possible that no ids are returned by an allocation, but a count. (In case of an offset)
-    #
-    def process! amount, offset = 0
-      @total = 0
-      current_offset = 0
-      @allocations.each do |allocation|
-        ids = allocation.process! amount, offset
-        @total = @total + allocation.count # the total mixed in
-        if ids.empty?
-          offset = offset - allocation.count unless offset.zero?
-        else
-          amount = amount - ids.size # we need less results from the following allocation
-          offset = 0                 # we have already passed the offset
-        end
-      end
-    end
-
-    def uniq
-      @allocations.uniq!
-    end
-
-    def to_a
-      @allocations
-    end
-
-    # Simply inspects the internal allocations.
-    #
-    def to_s
-      @allocations.inspect
-    end
-
-    # Allocations for results are in the form:
-    # [
-    #   allocation1.to_result,
-    #   allocation2.to_result
-    #   ...
-    # ]
-    #
-    def to_result
-      @allocations.map(&:to_result).compact
-    end
-
-  end
-end

data/lib/picky/query/combination.rb

@@ -1,74 +0,0 @@
-module Query
-
-  # Describes the combination of a token (the text) and
-  # the index (the bundle).
-  #
-  # A combination is a single part of an allocation.
-  #
-  # An allocation consists of a number of combinations.
-  #
-  class Combination # :nodoc:all
-
-    attr_reader :token, :bundle, :category_name
-
-    def initialize token, category
-      @token         = token
-      @category_name = category.name
-      @bundle        = category.bundle_for token
-      @text          = @token.text # don't want to use reset_similar already
-    end
-    
-    # Note: Required for uniq!
-    #
-    def hash
-      [@token.to_s, @bundle].hash
-    end
-    
-    # Returns the weight of this combination.
-    #
-    # Note: Caching is most oft the time useful.
-    #
-    def weight
-      @weight ||= @bundle.weight(@text)
-    end
-    
-    # Returns an array of ids for the given text.
-    #
-    # Note: Caching is most oft the time useful.
-    #
-    def ids
-      @ids ||= @bundle.ids(@text)
-    end
-    
-    # The identifier for this combination.
-    #
-    def identifier
-      @category_name
-    end
-    
-    # Is the identifier in the given identifiers?
-    #
-    def in? identifiers
-      identifiers.include? identifier
-    end
-
-    # Combines the category names with the original names.
-    # [
-    #  [:title,    'Flarbl', :flarbl],
-    #  [:category, 'Gnorf',  :gnorf]
-    # ]
-    #
-    def to_result
-      [identifier, *@token.to_result]
-    end
-    
-    # Example:
-    #  "exact title:Peter*:peter"
-    #
-    def to_s
-      "#{bundle.identifier} #{to_result.join(':')}"
-    end
-    
-  end
-
-end

data/lib/picky/query/combinations.rb

@@ -1,105 +0,0 @@
-module Query
-
-  # Combinations are a number of Combination-s.
-  #
-  # They are the core of an allocation.
-  #
-  class Combinations # :nodoc:all
-
-    attr_reader :combinations
-
-    delegate :empty?, :to => :@combinations
-
-    def initialize combinations = []
-      @combinations = combinations
-    end
-
-    def hash
-      @combinations.hash
-    end
-
-    # Uses user specific weights to calculate a score for the combinations.
-    #
-    def calculate_score weights
-      total_score + weighted_score(weights)
-    end
-    def total_score
-      @combinations.sum &:weight
-    end
-    def weighted_score weights
-      weights.score @combinations
-    end
-
-    # Gets all ids for the allocations.
-    #
-    # Sorts the ids by size and & through them in the following order (sizes):
-    # 0. [100_000, 400, 30, 2]
-    # 1. [2, 30, 400, 100_000]
-    # 2. (100_000 & (400 & (30 & 2))) # => result
-    #
-    # Returns the ids. Also sets the count.
-    #
-    # Note: Uses a C-optimized intersection routine for speed and memory efficiency.
-    #
-    def ids
-      return [] if @combinations.empty?
-
-      # Get the ids for each combination.
-      #
-      id_arrays = @combinations.inject([]) do |total, combination|
-        total << combination.ids
-      end
-
-      # Order by smallest size first such that the intersect can be performed faster.
-      #
-      # TODO Move into the memory_efficient_intersect such that
-      #      this precondition for a fast algorithm is always given.
-      #
-      id_arrays.sort! { |this_array, that_array| this_array.size <=> that_array.size }
-      
-      # Call the optimized C algorithm.
-      #
-      Performant::Array.memory_efficient_intersect id_arrays
-    end
-    
-    # Wrap the combinations into an allocation with the result_identifier.
-    #
-    def pack_into_allocation result_identifier
-      Allocation.new self, result_identifier
-    end
-    
-    # Filters the tokens and identifiers such that only identifiers
-    # that are passed in, remain, including their tokens.
-    #
-    # Note: This method is not totally independent of the calculate_ids one.
-    #       Since identifiers are only nullified, we need to not include the
-    #       ids that have an associated identifier that is nil.
-    #
-    def keep identifiers = []
-      # TODO Rewrite to use the category!!!
-      #
-      @combinations.reject! { |combination| !combination.in?(identifiers) }
-    end
-
-    # Filters the tokens and identifiers such that identifiers
-    # that are passed in, are removed, including their tokens.
-    #
-    # Note: This method is not totally independent of the calculate_ids one.
-    #       Since identifiers are only nullified, we need to not include the
-    #       ids that have an associated identifier that is nil.
-    #
-    def remove identifiers = []
-      # TODO Rewrite to use the category!!!
-      #
-      @combinations.reject! { |combination| combination.in?(identifiers) }
-    end
-
-    #
-    #
-    def to_result
-      @combinations.map &:to_result
-    end
-
-  end
-
-end

data/lib/picky/query/qualifiers.rb

@@ -1,77 +0,0 @@
-# coding: utf-8
-#
-
-#
-#
-module Query
-
-  # A single qualifier.
-  #
-  class Qualifier # :nodoc:all
-
-    attr_reader :normalized_qualifier, :codes
-
-    #
-    #
-    # codes is an array.
-    #
-    def initialize normalized_qualifier, codes
-      @normalized_qualifier = normalized_qualifier
-      @codes                = codes.map &:to_sym
-    end
-
-    # Will overwrite if the key is present in the hash.
-    #
-    def inject_into hash
-      codes.each do |code|
-        hash[code] = normalized_qualifier
-      end
-    end
-
-  end
-
-  # Collection class for qualifiers.
-  #
-  class Qualifiers # :nodoc:all
-
-    include Singleton
-
-    attr_reader :qualifiers, :normalization_mapping
-
-    delegate :<<, :to => :qualifiers
-
-    #
-    #
-    def initialize
-      @qualifiers = []
-      @normalization_mapping = {}
-    end
-    
-    # TODO Spec.
-    #
-    def self.add name, qualifiers
-      instance << Qualifier.new(name, qualifiers)
-    end
-    
-    # Uses the qualifiers to prepare (optimize) the qualifier handling.
-    #
-    def prepare
-      qualifiers.each do |qualifier|
-        qualifier.inject_into normalization_mapping
-      end
-    end
-
-    # Normalizes the given qualifier.
-    #
-    # Returns nil if it is not allowed, the normalized qualifier if it is.
-    #
-    # Note: Normalizes.
-    #
-    def normalize qualifier
-      return nil if qualifier.blank?
-
-      normalization_mapping[qualifier.to_sym]
-    end
-
-  end
-end

data/lib/picky/query/token.rb

@@ -1,202 +0,0 @@
-module Query
-  
-  # 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*).
-  #
-  # TODO Make partial / similarity char configurable.
-  #
-  class Token # :nodoc:all
-
-    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.
-    #
-    def initialize text
-      @text = text
-    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
-      token = new text
-      token.qualify
-      token.extract_original
-      token.partialize
-      token.similarize
-      token.remove_illegals
-      token
-    end
-
-    # This returns a predefined category name if the user has given one.
-    #
-    def user_defined_category_name
-      @qualifier
-    end
-
-    # Extracts a qualifier for this token and pre-assigns an allocation.
-    #
-    # Note: Removes the qualifier if it is not allowed.
-    #
-    def qualify
-      @qualifier, @text = split @text
-      @qualifier = Query::Qualifiers.instance.normalize @qualifier
-    end
-    def extract_original
-      @original = @text.dup
-    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
-
-    # If the text ends with *, partialize it. If with ", don't.
-    #
-    @@no_partial = /\"\Z/
-    @@partial    = /\*\Z/
-    def partialize
-      self.partial = false and return if @text =~ @@no_partial
-      self.partial = true if @text =~ @@partial
-    end
-
-    # If the text ends with ~ similarize it. If with ", don't.
-    #
-    @@no_similar = /\"\Z/
-    @@similar    = /\~\Z/
-    def similarize
-      self.similar = false and return if @text =~ @@no_similar
-      self.similar = true if @text =~ @@similar
-    end
-
-    def similar?
-      @similar
-    end
-
-    # Normalizes this token's text.
-    #
-    @@illegals = /["*~]/
-    def remove_illegals
-      @text.gsub! @@illegals, '' unless @text.blank?
-    end
-    
-    # Visitor for tokenizer.
-    #
-    # TODO Rewrite!!!
-    #
-    def tokenize_with tokenizer
-      @text = tokenizer.normalize @text
-    end
-    # TODO spec!
-    #
-    # TODO Rewrite!!
-    #
-    def tokenized tokenizer
-      tokenizer.tokenize(@text.to_s).each do |text|
-        yield text
-      end
-    end
-
-    # Returns an array of possible combinations.
-    #
-    def possible_combinations_in type
-      type.possible_combinations self
-    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
-
-    # Generates a solr term from this token.
-    #
-    # E.g. "name:heroes~0.75"
-    #
-    @@solr_fuzzy_mapping = {
-      1 => :'',
-      2 => :'',
-      3 => :'',
-      4 => :'~0.74',
-      5 => :'~0.78',
-      6 => :'~0.81',
-      7 => :'~0.83',
-      8 => :'~0.85',
-      9 => :'~0.87',
-     10 => :'~0.89'
-    }
-    @@solr_fuzzy_mapping.default = :'~0.9'
-    def to_solr
-      blank? ? '' : (to_s + @@solr_fuzzy_mapping[@text.size].to_s)
-    end
-    
-    #
-    #
-    def to_result
-      [@original, @text]
-    end
-    
-    # Displays the qualifier text and the text, joined.
-    #
-    # e.g. name:meier
-    #
-    def to_s
-      [@qualifier, @text].compact.join ':'
-    end
-    
-    private
-      
-      # Splits text into a qualifier and text.
-      #
-      # Returns [qualifier, text].
-      #
-      def split unqualified_text
-        qualifier, text = (unqualified_text || '').split(':', 2)
-        if text.blank?
-          [nil, (qualifier || '')]
-        else
-          [qualifier, text]
-        end
-      end
-
-  end
-end

data/lib/picky/query/tokens.rb

@@ -1,86 +0,0 @@
-# encoding: utf-8
-#
-
-#
-#
-module Query
-  
-  # This class primarily handles switching through similar token constellations.
-  #
-  class Tokens # :nodoc:all
-    
-    # Basically delegates to its internal tokens array.
-    #
-    self.delegate *[Enumerable.instance_methods, :slice!, :[], :uniq!, :last, :reject!, :length, :size, :empty?, :each, :exit, { :to => :@tokens }].flatten
-    
-    #
-    #
-    def initialize tokens = []
-      @tokens = tokens
-    end
-    
-    #
-    #
-    def tokenize_with tokenizer
-      @tokens.each { |token| token.tokenize_with(tokenizer) }
-    end
-    
-    # Generates an array in the form of
-    # [
-    #  [combination],                           # of token 1
-    #  [combination, combination, combination], # of token 2
-    #  [combination, combination]               # of token 3
-    # ]
-    #
-    # TODO If we want token behaviour defined per Query, we can
-    #      compact! here
-    #
-    def possible_combinations_in type
-      @tokens.inject([]) do |combinations, token|
-        combinations << token.possible_combinations_in(type)
-      end
-      # TODO compact! if ignore_unassigned_tokens
-    end
-
-    # Makes the last of the tokens partial.
-    #
-    def partialize_last
-      @tokens.last.partial = true unless empty?
-    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
-    
-    # Rejects blank tokens.
-    #
-    def reject
-      @tokens.reject! &:blank?
-    end
-    
-    # Returns a solr query.
-    #
-    def to_solr_query
-      @tokens.map(&:to_solr).join ' '
-    end
-    
-    #
-    #
-    def originals
-      @tokens.map(&:original)
-    end
-    
-    # Just join the token original texts.
-    #
-    def to_s
-      originals.join ' '
-    end
-    
-  end
-  
-end