picky 2.5.2 → 2.6.0

data/lib/picky/internals/index/files.rb

@@ -1,34 +0,0 @@
-module Internals
-
-  module Index
-
-    class Files < Backend
-
-      def initialize bundle_name, category
-        super bundle_name, category
-
-        # Note: We marshal the similarity, as the
-        #       Yajl json lib cannot load symbolized
-        #       values, just keys.
-        #
-        @index         = File::JSON.new    category.index_path(bundle_name, :index)
-        @weights       = File::JSON.new    category.index_path(bundle_name, :weights)
-        @similarity    = File::Marshal.new category.index_path(bundle_name, :similarity)
-        @configuration = File::JSON.new    category.index_path(bundle_name, :configuration)
-      end
-
-      def to_s
-        <<-FILES
-Files:
-#{"Index:      #{@index}".indented_to_s}
-#{"Weights:    #{@weights}".indented_to_s}
-#{"Similarity: #{@similarity}".indented_to_s}
-#{"Config:     #{@configuration}".indented_to_s}
-FILES
-      end
-
-    end
-
-  end
-
-end

data/lib/picky/internals/index/redis/basic.rb

@@ -1,89 +0,0 @@
-module Internals
-
-  module Index
-
-    class Redis
-
-      # Redis Backend Accessor.
-      #
-      # Provides necessary helper methods for its
-      # subclasses.
-      # Not directly useable, as it does not provide
-      # dump/load methods.
-      #
-      class Basic
-
-        attr_reader :namespace, :backend
-
-        # An index cache takes a path, without file extension,
-        # which will be provided by the subclasses.
-        #
-        def initialize namespace
-          @namespace = namespace
-
-          # TODO Turn this inside out such that people can pass in
-          # their own Redis instance.
-          #
-          # TODO Make the :db a real option.
-          #
-          @backend = ::Redis.new :db => 15
-        end
-
-        # Does nothing.
-        #
-        def load
-          # Nothing.
-        end
-        # We do not use Redis to retrieve data.
-        #
-        def retrieve
-          # Nothing.
-        end
-
-        # Redis does not backup.
-        #
-        def backup
-          # Nothing.
-        end
-
-        # Deletes the Redis index namespace.
-        #
-        def delete
-          # Not implemented here.
-          # Note: backend.flushdb might be the way to go,
-          #       but since we cannot delete by key pattern,
-          #       we don't do anything.
-        end
-
-        # Checks.
-        #
-
-        # Is this cache suspiciously small?
-        #
-        def cache_small?
-          size < 1
-        end
-        # Is the cache ok?
-        #
-        # A small cache is still ok.
-        #
-        def cache_ok?
-          size > 0
-        end
-        # Extracts the size of the file in Bytes.
-        #
-        # Note: This is a very forgiving implementation.
-        #       But as long as Redis does not implement
-        #       DBSIZE KEYPATTERN, we are stuck with this.
-        #
-        def size
-          backend.dbsize
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/picky/internals/index/redis/list_hash.rb

@@ -1,53 +0,0 @@
-module Internals
-
-  module Index
-
-    class Redis
-
-      class ListHash < Basic
-
-        # Writes the hash into Redis.
-        #
-        def dump hash
-          clear
-          hash.each_pair do |key, values|
-            redis_key = "#{namespace}:#{key}"
-            i = 0
-            values.each do |value|
-              i += 1
-              backend.zadd redis_key, i, value
-            end
-          end
-        end
-        
-        # Clear the index for this list.
-        #
-        # Note: Perhaps we can use a server only command.
-        #       This is not the optimal way to do it.
-        #
-        def clear
-          redis_key = "#{namespace}:*"
-          backend.keys(redis_key).each do |key|
-            backend.del key
-          end
-        end
-
-        # Get a collection.
-        #
-        def collection sym
-          backend.lrange "#{namespace}:#{sym}", 0, -1
-        end
-
-        # Get a single value.
-        #
-        def member sym
-          raise "Can't retrieve a single value from a Redis ListHash. Use Index::Redis::StringHash."
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/picky/internals/index/redis/string_hash.rb

@@ -1,44 +0,0 @@
-module Internals
-
-  module Index
-
-    class Redis
-
-      class StringHash < Basic
-
-        # Writes the hash into Redis.
-        #
-        # Note: We could use multi, but it did not help.
-        #
-        def dump hash
-          clear
-          hash.each_pair do |key, value|
-            backend.hset namespace, key, value
-          end
-        end
-        
-        # Clears the hash.
-        #
-        def clear
-          backend.del namespace
-        end
-
-        # Get a collection.
-        #
-        def collection sym
-          raise "Can't retrieve a collection from a StringHash. Use Index::Redis::ListHash."
-        end
-
-        # Get a single value.
-        #
-        def member sym
-          backend.hget namespace, sym
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/picky/internals/index/redis.rb

@@ -1,44 +0,0 @@
-module Internals
-
-  module Index
-
-    # TODO Needs a reconnect to be run after forking.
-    #
-    class Redis < Backend
-
-      def initialize bundle_name, category
-        super bundle_name, category
-
-        # Refine a few Redis "types".
-        #
-        @index         = Redis::ListHash.new "#{category.identifier}:#{bundle_name}:index"
-        @weights       = Redis::StringHash.new "#{category.identifier}:#{bundle_name}:weights"
-        @similarity    = Redis::ListHash.new "#{category.identifier}:#{bundle_name}:similarity"
-        @configuration = Redis::StringHash.new "#{category.identifier}:#{bundle_name}:configuration"
-      end
-
-      # Delegate to the right collection.
-      #
-      def ids sym
-        index.collection sym
-      end
-
-      # Delegate to the right member value.
-      #
-      # Note: Converts to float.
-      #
-      def weight sym
-        weights.member(sym).to_f
-      end
-
-      # Delegate to a member value.
-      #
-      def setting sym
-        configuration.member sym
-      end
-
-    end
-
-  end
-
-end

data/lib/picky/internals/indexed/bundle/base.rb

@@ -1,114 +0,0 @@
-module Internals
-
-  module Indexed # :nodoc:all
-
-    # A Bundle is a number of indexes
-    # per [index, category] combination.
-    #
-    # At most, there are three indexes:
-    # * *core* index (always used)
-    # * *weights* index (always used)
-    # * *similarity* index (used with similarity)
-    #
-    # In Picky, indexing is separated from the index
-    # handling itself through a parallel structure.
-    #
-    # Both use methods provided by this base class, but
-    # have very different goals:
-    #
-    # * *Indexing*::*Bundle* is just concerned with creating index files
-    #   and providing helper functions to e.g. check the indexes.
-    #
-    # * *Index*::*Bundle* is concerned with loading these index files into
-    #   memory and looking up search data as fast as possible.
-    #
-    module Bundle
-
-      class Base
-
-        attr_reader   :identifier, :configuration
-        attr_accessor :similarity_strategy
-        attr_accessor :index, :weights, :similarity, :configuration
-
-        delegate :[], :to => :configuration
-        delegate :size, :to => :index
-
-        def initialize name, category, similarity_strategy
-          @identifier = "#{category.identifier}:#{name}"
-
-          @index         = {}
-          @weights       = {}
-          @similarity    = {}
-
-          @similarity_strategy = similarity_strategy
-        end
-
-        # Get a list of similar texts.
-        #
-        # Note: Does not return itself.
-        #
-        def similar text
-          code = similarity_strategy.encoded text
-          similar_codes = code && @similarity[code]
-          similar_codes.delete text if similar_codes
-          similar_codes || []
-        end
-
-        # Loads all indexes.
-        #
-        def load
-          load_index
-          load_weights
-          load_similarity
-          load_configuration
-        end
-
-        # Loads the core index.
-        #
-        def load_index
-          # No loading needed.
-        end
-        # Loads the weights index.
-        #
-        def load_weights
-          # No loading needed.
-        end
-        # Loads the similarity index.
-        #
-        def load_similarity
-          # No loading needed.
-        end
-        # Loads the configuration.
-        #
-        def load_configuration
-          # No loading needed.
-        end
-
-        # Loads the core index.
-        #
-        def clear_index
-          # No loading needed.
-        end
-        # Loads the weights index.
-        #
-        def clear_weights
-          # No loading needed.
-        end
-        # Loads the similarity index.
-        #
-        def clear_similarity
-          # No loading needed.
-        end
-        # Loads the configuration.
-        #
-        def clear_configuration
-          # No loading needed.
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/picky/internals/indexed/bundle/memory.rb

@@ -1,95 +0,0 @@
-module Internals
-
-  # encoding: utf-8
-  #
-  module Indexed # :nodoc:all
-
-    #
-    #
-    module Bundle
-
-      # This is the _actual_ index (based on memory).
-      #
-      # Handles exact/partial index, weights index, and similarity index.
-      #
-      # Delegates file handling and checking to an *Indexed*::*Files* object.
-      #
-      class Memory < Base
-
-        delegate :[], :to => :configuration
-
-        def initialize name, configuration, *args
-          super name, configuration, *args
-
-          @configuration = {} # A hash with config options.
-
-          @backend = Internals::Index::Files.new name, configuration
-        end
-
-        def to_s
-          <<-MEMORY
-Memory
-#{@backend.indented_to_s}
-MEMORY
-        end
-
-        # Get the ids for the given symbol.
-        #
-        def ids sym
-          @index[sym] || []
-        end
-        # Get a weight for the given symbol.
-        #
-        def weight sym
-          @weights[sym]
-        end
-
-        # Loads the core index.
-        #
-        def load_index
-          self.index = @backend.load_index
-        end
-        # Loads the weights index.
-        #
-        def load_weights
-          self.weights = @backend.load_weights
-        end
-        # Loads the similarity index.
-        #
-        def load_similarity
-          self.similarity = @backend.load_similarity
-        end
-        # Loads the configuration.
-        #
-        def load_configuration
-          self.configuration = @backend.load_configuration
-        end
-
-        # Loads the core index.
-        #
-        def clear_index
-          self.index = {}
-        end
-        # Loads the weights index.
-        #
-        def clear_weights
-          self.weights = {}
-        end
-        # Loads the similarity index.
-        #
-        def clear_similarity
-          self.similarity = {}
-        end
-        # Loads the configuration.
-        #
-        def clear_configuration
-          self.configuration = {}
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/picky/internals/indexed/bundle/redis.rb

@@ -1,49 +0,0 @@
-module Internals
-
-  # encoding: utf-8
-  #
-  module Indexed # :nodoc:all
-
-    #
-    #
-    module Bundle
-
-      # This is the _actual_ index (based on Redis).
-      #
-      # Handles exact/partial index, weights index, and similarity index.
-      #
-      class Redis < Base
-
-        def initialize name, category, *args
-          super name, category, *args
-
-          @backend = Internals::Index::Redis.new name, category
-        end
-
-        # Get the ids for the given symbol.
-        #
-        # Ids are an array of string values in Redis.
-        #
-        def ids sym
-          @backend.ids sym
-        end
-        # Get a weight for the given symbol.
-        #
-        # A weight is a string value in Redis. TODO Convert?
-        #
-        def weight sym
-          @backend.weight sym
-        end
-        # Settings of this bundle can be accessed via [].
-        #
-        def [] sym
-          @backend.setting sym
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/picky/internals/indexed/categories.rb

@@ -1,140 +0,0 @@
-module Internals
-
-  module Indexed
-
-    class Categories
-
-      attr_reader :categories, :category_hash, :ignore_unassigned_tokens
-
-      each_delegate :load_from_cache,
-                    :analyze,
-                    :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
-
-        @ignore_unassigned_tokens = options[:ignore_unassigned_tokens] || false
-      end
-
-      def to_s
-        categories.indented_to_s
-      end
-
-      # Clears both the array of categories and the hash of categories.
-      #
-      def clear
-        @categories    = []
-        @category_hash = {}
-      end
-
-      # Add the given category to the list of categories.
-      #
-      def << category
-        categories << category
-        category_hash[category.name] = category
-      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_for token
-        token.similar? ? similar_possible_for(token) : possible_for(token)
-      end
-      # Gets all similar tokens and puts together the possible combinations
-      # for each found similar token.
-      #
-      def similar_possible_for token
-        # Get as many tokens as necessary
-        #
-        tokens = similar_tokens_for token
-        # possible combinations
-        #
-        inject_possible_for tokens
-      end
-      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
-      def inject_possible_for tokens
-        tokens.inject([]) do |result, token|
-          possible = possible_categories token
-          result + possible_for(token, possible)
-        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
-        end
-        # This is an optimization to mark tokens that are ignored.
-        #
-        return if ignore_unassigned_tokens && possible.empty?
-        possible # wrap in combinations
-      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 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
-
-  end
-
-end