picky 2.5.2 → 2.6.0

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

@@ -1,111 +0,0 @@
-module Internals
-
-  module Indexed
-
-    # An index category holds a exact and a partial index for a given category.
-    #
-    # For example an index category for names holds a exact and
-    # a partial index bundle for names.
-    #
-    class Category
-
-      include Internals::Shared::Category
-
-      attr_accessor :exact
-      attr_reader   :name, :index
-      attr_writer   :partial
-
-      #
-      #
-      def initialize name, index, options = {}
-        @name  = name
-        @index = index
-
-        # TODO Push the defaults out into the index.
-        #
-        @partial_strategy = options[:partial] || Internals::Generators::Partial::Default
-        similarity = options[:similarity] || Internals::Generators::Similarity::Default
-
-        bundle_class = options[:indexed_bundle_class] || Bundle::Memory
-        @exact   = bundle_class.new :exact,   self, similarity
-        @partial = 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]
-
-        # TODO Extract?
-        #
-        Query::Qualifiers.add(name, generate_qualifiers_from(options) || [name])
-      end
-
-      def to_s
-<<-CATEGORY
-Category(#{name}):
-  Exact:
-#{exact.indented_to_s(4)}
-  Partial:
-#{partial.indented_to_s(4)}
-CATEGORY
-      end
-
-      # TODO Move to Index.
-      #
-      def generate_qualifiers_from options
-        options[:qualifiers] || options[:qualifier] && [options[:qualifier]]
-      end
-
-      # Loads the index from cache.
-      #
-      def load_from_cache
-        timed_exclaim %Q{"#{identifier}": Loading index from cache.}
-        exact.load
-        partial.load
-      end
-
-      # Loads, analyzes, and clears the index.
-      #
-      # Note: The idea is not to run this while the search engine is running.
-      #
-      def analyze collector
-        collector[identifier] = {
-          :exact   => Analyzer.new.analyze(exact),
-          :partial => Analyzer.new.analyze(partial)
-        }
-        collector
-      end
-
-      # 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?? partial : exact
-      end
-
-      # The partial strategy defines whether to really use the partial index.
-      #
-      def partial
-        @partial_strategy.use_exact_for_partial?? @exact : @partial
-      end
-
-      #
-      #
-      def combination_for token
-        weight(token) && Internals::Query::Combination.new(token, self)
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,63 +0,0 @@
-module Internals
-
-  module Indexed
-
-    #
-    #
-    class Index
-
-      attr_reader :name, :result_identifier, :combinator, :categories
-
-      delegate :load_from_cache,
-               :analyze,
-               :to => :categories
-
-      def initialize name, options = {}
-        @name                     = name
-
-        @result_identifier        = options[:result_identifier] || name
-        @bundle_class             = options[:indexed_bundle_class] # TODO This should actually be a fixed parameter.
-        ignore_unassigned_tokens  = options[:ignore_unassigned_tokens] || false # TODO Move to query, somehow.
-
-        @categories = Categories.new ignore_unassigned_tokens: ignore_unassigned_tokens
-      end
-
-      def define_category category_name, options = {}
-        options = default_category_options.merge options
-
-        new_category = Category.new category_name, self, options
-        categories << new_category
-        new_category
-      end
-
-      # By default, the category uses
-      # * the index's bundle type.
-      #
-      def default_category_options
-        {
-          :indexed_bundle_class => @bundle_class
-        }
-      end
-
-      # Return the possible combinations for this token.
-      #
-      # A combination is a tuple <token, index_bundle>.
-      #
-      def possible_combinations token
-        categories.possible_combinations_for token
-      end
-
-      def to_s
-        <<-INDEX
-Indexed(#{name}):
-  Result identifier: "#{result_identifier}"
-  Categories:
-  #{categories.indented_to_s}
-INDEX
-      end
-
-    end
-
-  end
-
-end

data/lib/picky/internals/indexed/wrappers/bundle/calculation.rb

@@ -1,37 +0,0 @@
-module Internals
-  module Indexed
-    module Wrappers
-
-      module Bundle
-
-        # A calculation rewrites the symbol into a float.
-        #
-        # TODO I really need to allow integers as keys. The code below is just not up to the needed quality.
-        #
-        class Calculation < Wrapper
-
-          #
-          #
-          def recalculate float
-            float
-          end
-
-          #
-          #
-          def ids sym
-            @bundle.ids recalculate(sym.to_s.to_f).to_s.to_sym
-          end
-
-          #
-          #
-          def weight sym
-            @bundle.weight recalculate(sym.to_s.to_f).to_s.to_sym
-          end
-
-        end
-
-      end
-
-    end
-  end
-end

data/lib/picky/internals/indexed/wrappers/bundle/location.rb

@@ -1,44 +0,0 @@
-module Internals
-  module Indexed
-    module Wrappers
-
-      module Bundle
-
-        # A location calculation recalculates a location to the Picky internal location.
-        #
-        class Location < Calculation
-
-          def initialize bundle, options = {}
-            super bundle
-
-            precision  = options[:precision] || 1
-            user_grid  = options[:grid] || raise("Gridsize needs to be given for location #{bundle.identifier}.")
-
-            @calculation = Internals::Calculations::Location.new user_grid, precision
-          end
-
-          #
-          #
-          def recalculate float
-            @calculation.recalculate float
-          end
-
-          #
-          #
-          def load
-            # Load first the bundle, then extract the config.
-            #
-            bundle.load
-            # TODO Move the to_f to the backend.
-            #
-            minimum = bundle[:location_minimum] && bundle[:location_minimum].to_f || raise("Configuration :location_minimum for #{bundle.identifier} missing. Did you run rake index already?")
-            @calculation.minimum = minimum
-          end
-
-        end
-
-      end
-
-    end
-  end
-end

data/lib/picky/internals/indexed/wrappers/bundle/wrapper.rb

@@ -1,45 +0,0 @@
-module Internals
-  module Indexed
-    module Wrappers
-
-      # Per Bundle wrappers.
-      #
-      module Bundle
-
-        # Base wrapper. Just delegates all methods to the bundle.
-        #
-        class Wrapper
-
-          attr_reader :bundle
-
-          def initialize bundle
-            @bundle = bundle
-          end
-
-          delegate :load,
-                   :load_index,
-                   :load_weights,
-                   :load_similarity,
-                   :load_configuration,
-                   :clear_index,
-                   :clear_weights,
-                   :clear_similarity,
-                   :clear_configuration,
-                   :ids,
-                   :weight,
-                   :identifier,
-                   :analyze,
-                   :size,
-                   :index,
-                   :weights,
-                   :similarity,
-                   :configuration,
-                   :to => :@bundle
-
-        end
-
-      end
-
-    end
-  end
-end

data/lib/picky/internals/indexed/wrappers/category/location.rb

@@ -1,27 +0,0 @@
-module Internals
-  module Indexed
-    module Wrappers
-      module Category
-
-        module Location
-
-          def self.install_on category, grid, precision = 1
-            wrapped_exact = Internals::Indexed::Wrappers::Bundle::Location.new category.exact, grid: grid, precision: precision
-
-            category.class_eval do
-              define_method :exact do
-                wrapped_exact
-              end
-              define_method :partial do
-                wrapped_exact
-              end
-            end
-
-          end
-
-        end
-
-      end
-    end
-  end
-end

data/lib/picky/internals/indexed/wrappers/exact_first.rb

@@ -1,59 +0,0 @@
-module Internals
-
-  # encoding: utf-8
-  #
-  module Indexed
-
-    module Wrappers
-
-      # This index combines an exact and partial index.
-      # It serves to order the results such that exact hits are found first.
-      #
-      class ExactFirst < Indexed::Bundle::Base
-
-        delegate :similar,
-                 :identifier,
-                 :name,
-                 :to => :@exact
-        delegate :index,
-                 :category,
-                 :weight,
-                 :generate_partial_from,
-                 :generate_caches_from_memory,
-                 :generate_derived,
-                 :dump,
-                 :load,
-                 :to => :@partial
-
-        def initialize category
-          @exact   = category.exact
-          @partial = category.partial
-        end
-
-        def self.wrap index_or_category
-          if index_or_category.respond_to? :categories
-            wrap_each_of index_or_category.categories
-            index_or_category
-          else
-            new index_or_category
-          end
-        end
-        def self.wrap_each_of categories
-          categories.categories.collect! { |category| new(category) }
-        end
-
-        def ids text
-          @exact.ids(text) + @partial.ids(text)
-        end
-
-        def weight text
-          [@exact.weight(text) || 0, @partial.weight(text) || 0].max
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,216 +0,0 @@
-# encoding: utf-8
-#
-module Internals
-
-  module Indexing # :nodoc:all
-
-    module Bundle
-
-      # This is the indexing bundle.
-      # It does all menial tasks that have nothing to do
-      # with the actual index running etc.
-      #
-      class Base < SuperBase
-
-        attr_accessor :partial_strategy, :weights_strategy
-
-        # Path is in which directory the cache is located.
-        #
-        def initialize name, category, similarity_strategy, partial_strategy, weights_strategy
-          super name, category, similarity_strategy
-
-          @partial_strategy    = partial_strategy
-          @weights_strategy    = weights_strategy
-        end
-
-        # Sets up a piece of the index for the given token.
-        #
-        def initialize_index_for token
-          index[token] ||= []
-        end
-
-        # Generation
-        #
-
-        # This method
-        # * Loads the base index from the "prepared..." file.
-        # * Generates derived indexes.
-        # * Dumps all the indexes into files.
-        #
-        def generate_caches_from_source
-          load_from_index_file
-          generate_caches_from_memory
-        end
-        # Generates derived indexes from the index and dumps.
-        #
-        # Note: assumes that there is something in the index
-        #
-        def generate_caches_from_memory
-          cache_from_memory_generation_message
-          generate_derived
-        end
-        def cache_from_memory_generation_message
-          timed_exclaim %Q{"#{identifier}": Caching from intermediate in-memory index.}
-        end
-
-        # Generates the weights and similarity from the main index.
-        #
-        def generate_derived
-          generate_weights
-          generate_similarity
-        end
-
-        # Load the data from the db.
-        #
-        def load_from_index_file
-          load_from_index_generation_message
-          clear
-          retrieve
-        end
-        def load_from_index_generation_message
-          timed_exclaim %Q{"#{identifier}": Loading index.}
-        end
-        # Retrieves the prepared index data into the index.
-        #
-        # This is in preparation for generating
-        # derived indexes (like weights, similarity)
-        # and later dumping the optimized index.
-        #
-        def retrieve
-          key_format = self[:key_format] || :to_i
-          files.retrieve do |id, token|
-            initialize_index_for token
-            index[token] << id.send(key_format)
-          end
-        end
-
-        # Generates a new index (writes its index) using the
-        # partial caching strategy of this bundle.
-        #
-        def generate_partial
-          generator = Generators::PartialGenerator.new self.index
-          self.index = generator.generate self.partial_strategy
-        end
-        # Generate a partial index from the given exact index.
-        #
-        def generate_partial_from exact_index
-          timed_exclaim %Q{"#{identifier}": Generating partial index for index.}
-          self.index = exact_index
-          self.generate_partial
-          self
-        end
-        # Generates a new similarity index (writes its index) using the
-        # given similarity caching strategy.
-        #
-        def generate_similarity
-          generator = Generators::SimilarityGenerator.new self.index
-          self.similarity = generator.generate self.similarity_strategy
-        end
-        # Generates a new weights index (writes its index) using the
-        # given weight caching strategy.
-        #
-        def generate_weights
-          generator = Generators::WeightsGenerator.new self.index
-          self.weights = generator.generate self.weights_strategy
-        end
-
-        # Saves the indexes in a dump file.
-        #
-        def dump
-          dump_index
-          dump_similarity
-          dump_weights
-          dump_configuration
-        end
-        # Dumps the core index.
-        #
-        def dump_index
-          timed_exclaim %Q{"#{identifier}": Dumping index.}
-          backend.dump_index index
-        end
-        # Dumps the weights index.
-        #
-        def dump_weights
-          timed_exclaim %Q{"#{identifier}": Dumping weights of index.}
-          backend.dump_weights weights
-        end
-        # Dumps the similarity index.
-        #
-        def dump_similarity
-          timed_exclaim %Q{"#{identifier}": Dumping similarity of index.}
-          backend.dump_similarity similarity
-        end
-        # Dumps the similarity index.
-        #
-        def dump_configuration
-          timed_exclaim %Q{"#{identifier}": Dumping configuration for index.}
-          backend.dump_configuration configuration
-        end
-
-        # Alerts the user if an index is missing.
-        #
-        def raise_unless_cache_exists
-          raise_unless_index_exists
-          raise_unless_similarity_exists
-        end
-        # Alerts the user if one of the necessary indexes
-        # (core, weights) is missing.
-        #
-        def raise_unless_index_exists
-          if partial_strategy.saved?
-            warn_if_index_small
-            raise_unless_index_ok
-          end
-        end
-        # Alerts the user if the similarity
-        # index is missing (given that it's used).
-        #
-        def raise_unless_similarity_exists
-          if similarity_strategy.saved?
-            warn_if_similarity_small
-            raise_unless_similarity_ok
-          end
-        end
-
-        # Outputs a warning for the given cache.
-        #
-        def warn_cache_small what
-          warn "Warning: #{what} cache for #{identifier} smaller than 16 bytes."
-        end
-        # Raises an appropriate error message for the given cache.
-        #
-        def raise_cache_missing what
-          raise "Error: The #{what} cache for #{identifier} is missing."
-        end
-
-        # Warns the user if the similarity index is small.
-        #
-        def warn_if_similarity_small
-          warn_cache_small :similarity if backend.similarity_cache_small?
-        end
-        # Alerts the user if the similarity index is not there.
-        #
-        def raise_unless_similarity_ok
-          raise_cache_missing :similarity unless backend.similarity_cache_ok?
-        end
-
-        # Warns the user if the core or weights indexes are small.
-        #
-        def warn_if_index_small
-          warn_cache_small :index   if backend.index_cache_small?
-          warn_cache_small :weights if backend.weights_cache_small?
-        end
-        # Alerts the user if the core or weights indexes are not there.
-        #
-        def raise_unless_index_ok
-          raise_cache_missing :index   unless backend.index_cache_ok?
-          raise_cache_missing :weights unless backend.weights_cache_ok?
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,29 +0,0 @@
-# encoding: utf-8
-#
-module Internals
-
-  module Indexing # :nodoc:all
-
-    module Bundle
-
-      # The memory version dumps its generated indexes to disk
-      # (mostly JSON) to load them into memory on startup.
-      #
-      class Memory < Base
-
-        # We're using files for the memory backend.
-        # E.g. dump writes files.
-        #
-        alias backend files
-
-        def to_s
-          "Memory\n#{@backend.indented_to_s}"
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,28 +0,0 @@
-# encoding: utf-8
-#
-module Internals
-
-  module Indexing # :nodoc:all
-
-    module Bundle
-
-      # The Redis version dumps its generated indexes to
-      # the Redis backend.
-      #
-      class Redis < Base
-
-        attr_reader :backend
-
-        def initialize name, category, *args
-          super name, category, *args
-
-          @backend = Internals::Index::Redis.new name, category
-        end
-
-      end
-
-    end
-
-  end
-
-end