picky 2.7.0 → 3.0.0.pre1

data/lib/picky/query/allocation.rb

@@ -1,82 +1,86 @@
-module Query
+module Picky
 
-  # An allocation has a number of combinations:
-  # [token, index] [other_token, other_index], ...
-  #
-  class Allocation # :nodoc:all
+  module Query
 
-    attr_reader :count, :ids, :score, :combinations, :result_identifier
-
-    #
+    # An allocation has a number of combinations:
+    # [token, index] [other_token, other_index], ...
     #
-    def initialize combinations, result_identifier
-      @combinations      = combinations
-      @result_identifier = result_identifier
-    end
+    class Allocation # :nodoc:all
 
-    def hash
-      @combinations.hash
-    end
-    def eql? other_allocation
-      true # FIXME
-      # @combinations.eql? other_allocation.combinations
-    end
+      attr_reader :count, :ids, :score, :combinations, :result_identifier
 
-    # Scores its combinations and caches the result.
-    #
-    def calculate_score weights
-      @score ||= @combinations.calculate_score(weights)
-    end
+      #
+      #
+      def initialize combinations, result_identifier
+        @combinations      = combinations
+        @result_identifier = result_identifier
+      end
 
-    # Asks the combinations for the (intersected) ids.
-    #
-    def calculate_ids amount, offset
-      @combinations.ids amount, offset # Calculate as many ids as are necessary.
-    end
+      def hash
+        @combinations.hash
+      end
+      def eql? other_allocation
+        true # FIXME
+        # @combinations.eql? other_allocation.combinations
+      end
 
-    # This starts the searching process.
-    #
-    def process! amount, offset
-      ids    = calculate_ids amount, offset
-      @count = ids.size                         # cache the count before throwing away the ids
-      @ids   = ids.slice!(offset, amount) || [] # slice out the relevant part
-    end
+      # Scores its combinations and caches the result.
+      #
+      def calculate_score weights
+        @score ||= @combinations.calculate_score(weights)
+      end
 
-    #
-    #
-    def keep identifiers = [] # categories
-      @combinations.keep identifiers
-    end
-    #
-    #
-    def remove identifiers = [] # categories
-      @combinations.remove identifiers
-    end
+      # Asks the combinations for the (intersected) ids.
+      #
+      def calculate_ids amount, offset
+        @combinations.ids amount, offset # Calculate as many ids as are necessary.
+      end
 
-    # Sort highest score first.
-    #
-    def <=> other_allocation
-       other_allocation.score <=> self.score
-    end
+      # This starts the searching process.
+      #
+      def process! amount, offset
+        ids    = calculate_ids amount, offset
+        @count = ids.size                         # cache the count before throwing away the ids
+        @ids   = ids.slice!(offset, amount) || [] # slice out the relevant part
+      end
 
-    # Transform the allocation into result form.
-    #
-    def to_result
-      [self.result_identifier, self.score, self.count, @combinations.to_result, self.ids] if self.count > 0
-    end
+      #
+      #
+      def keep identifiers = [] # categories
+        @combinations.keep identifiers
+      end
+      #
+      #
+      def remove identifiers = [] # categories
+        @combinations.remove identifiers
+      end
 
-    # Json representation of this allocation.
-    #
-    # Note: Delegates to to_result.
-    #
-    def to_json
-      to_result.to_json
-    end
+      # Sort highest score first.
+      #
+      def <=> other_allocation
+         other_allocation.score <=> self.score
+      end
+
+      # Transform the allocation into result form.
+      #
+      def to_result
+        [self.result_identifier, self.score, self.count, @combinations.to_result, self.ids] if self.count > 0
+      end
+
+      # Json representation of this allocation.
+      #
+      # Note: Delegates to to_result.
+      #
+      def to_json
+        to_result.to_json
+      end
+
+      #
+      #
+      def to_s
+        "Allocation(#{to_result})"
+      end
 
-    #
-    #
-    def to_s
-      "Allocation(#{to_result})"
     end
 
   end

data/lib/picky/query/allocations.rb

@@ -1,112 +1,117 @@
-module Query
-  # Container class for allocations.
-  #
-  class Allocations # :nodoc:all
+module Picky
 
-    delegate :each, :inject, :empty?, :size, :to => :@allocations
-    attr_reader :total
+  module Query
 
-    def initialize allocations = []
-      @allocations = allocations
-    end
-
-    # Score each allocation.
+    # Container class for allocations.
     #
-    def calculate_score weights
-      @allocations.each do |allocation|
-        allocation.calculate_score weights
+    class Allocations # :nodoc:all
+
+      delegate :each, :inject, :empty?, :size, :to => :@allocations
+      attr_reader :total
+
+      def initialize allocations = []
+        @allocations = allocations
       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
+      # 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
 
-    # 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.
-    #
-    def remove identifiers = []
-      @allocations.each { |allocation| allocation.remove identifiers } unless identifiers.empty?
-    end
+      # Reduces the amount of allocations to x.
+      #
+      def reduce_to amount
+        @allocations = @allocations.shift amount
+      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
+      # 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.
+      #
+      def remove identifiers = []
+        @allocations.each { |allocation| allocation.remove identifiers } unless identifiers.empty?
       end
-    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
+      # 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
-    end
 
-    def uniq
-      @allocations.uniq!
-    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 to_a
-      @allocations
-    end
+      def uniq
+        @allocations.uniq!
+      end
 
-    # Simply inspects the internal allocations.
-    #
-    def to_s
-      @allocations.inspect
-    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
 
-    # Allocations for results are in the form:
-    # [
-    #   allocation1.to_result,
-    #   allocation2.to_result
-    #   ...
-    # ]
-    #
-    def to_result
-      @allocations.map(&:to_result).compact
     end
 
   end

data/lib/picky/query/combination.rb

@@ -1,76 +1,80 @@
-module Query
+module Picky
 
-  # Describes the combination of a token (the text) and
-  # the index (the bundle): [text, index_bundle]
-  #
-  # A combination is a single part of an allocation:
-  # [..., [text2, index_bundle2], ...]
-  #
-  # An allocation consists of a number of combinations:
-  # [[text1, index_bundle1], [text2, index_bundle2], [text3, index_bundle1]]
-  #
-  class Combination # :nodoc:all
+  module Query
 
-    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 of the time useful.
-    #
-    def weight
-      @weight ||= @bundle.weight(@text)
-    end
-  
-    # Returns an array of ids for the given text.
-    #
-    # Note: Caching is most of the time useful.
+    # Describes the combination of a token (the text) and
+    # the index (the bundle): [text, index_bundle]
     #
-    def ids
-      @ids ||= @bundle.ids(@text)
-    end
-  
-    # The identifier for this combination.
+    # A combination is a single part of an allocation:
+    # [..., [text2, index_bundle2], ...]
     #
-    def identifier
-      "#{bundle.identifier}:#{@token.identifier}"
-    end
-  
-    # Is the identifier in the given identifiers?
+    # An allocation consists of a number of combinations:
+    # [[text1, index_bundle1], [text2, index_bundle2], [text3, index_bundle1]]
     #
-    def in? identifiers
-      identifiers.include? identifier
-    end
+    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 of the time useful.
+      #
+      def weight
+        @weight ||= @bundle.weight(@text)
+      end
+
+      # Returns an array of ids for the given text.
+      #
+      # Note: Caching is most of the time useful.
+      #
+      def ids
+        @ids ||= @bundle.ids(@text)
+      end
+
+      # The identifier for this combination.
+      #
+      def identifier
+        "#{bundle.identifier}:#{@token.identifier}"
+      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
+        [@category_name, *@token.to_result]
+      end
+
+      # Example:
+      #  "exact title:Peter*:peter"
+      #
+      def to_s
+        "#{bundle.identifier} #{to_result.join(':')}"
+      end
 
-    # Combines the category names with the original names.
-    # [
-    #  [:title,    'Flarbl', :flarbl],
-    #  [:category, 'Gnorf',  :gnorf]
-    # ]
-    #
-    def to_result
-      [@category_name, *@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/base.rb

@@ -1,66 +1,70 @@
-module Query
+module Picky
 
-  # Combinations are a number of Combination-s.
-  #
-  # They are the core of an allocation.
-  # An allocation consists of a number of combinations.
-  #
-  module Combinations # :nodoc:all
+  module Query
 
-    # Base Combinations contain methods for calculating score and ids.
+    # Combinations are a number of Combination-s.
     #
-    class Base
+    # They are the core of an allocation.
+    # An allocation consists of a number of combinations.
+    #
+    module Combinations # :nodoc:all
 
-      attr_reader :combinations
+      # Base Combinations contain methods for calculating score and ids.
+      #
+      class Base
 
-      delegate :empty?, :to => :@combinations
+        attr_reader :combinations
 
-      def initialize combinations = []
-        @combinations = combinations
-      end
+        delegate :empty?, :to => :@combinations
 
-      def hash
-        @combinations.hash
-      end
+        def initialize combinations = []
+          @combinations = combinations
+        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
+        def hash
+          @combinations.hash
+        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 = []
-        @combinations.reject! { |combination| !combination.in?(identifiers) }
-      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
 
-      # 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 = []
-        @combinations.reject! { |combination| combination.in?(identifiers) }
-      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 = []
+          @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 = []
+          @combinations.reject! { |combination| combination.in?(identifiers) }
+        end
+
+        #
+        #
+        def to_result
+          @combinations.map &:to_result
+        end
 
-      #
-      #
-      def to_result
-        @combinations.map &:to_result
       end
 
     end