picky 3.5.0 → 3.5.1

data/lib/picky/bundle.rb

@@ -66,8 +66,11 @@ module Picky
 
       # Initial indexes.
       #
+      # Note that if the weights strategy doesn't need to be saved,
+      # the strategy itself pretends to be an index.
+      #
       @inverted      = @backend_inverted.initial
-      @weights       = @backend_weights.initial
+      @weights       = @weights_strategy.saved?? @backend_weights.initial : @weights_strategy
       @similarity    = @backend_similarity.initial
       @configuration = @backend_configuration.initial
 
@@ -77,6 +80,30 @@ module Picky
       "#{category.identifier}:#{name}"
     end
 
+    # "Empties" the index(es) by getting a new empty
+    # internal backend instance.
+    #
+    def empty
+      empty_inverted
+      empty_weights
+      empty_similarity
+      empty_configuration
+    end
+    def empty_inverted
+      @inverted = @backend_inverted.empty
+    end
+    def empty_weights
+      # TODO THINK about this. Perhaps the strategies should implement the backend methods?
+      #
+      @weights = @weights_strategy.saved?? @backend_weights.empty : @weights_strategy
+    end
+    def empty_similarity
+      @similarity = @backend_similarity.empty
+    end
+    def empty_configuration
+      @configuration = @backend_configuration.empty
+    end
+
     # Get a list of similar texts.
     #
     # Note: Does not return itself.
@@ -113,7 +140,9 @@ module Picky
     #
     def backup
       @backend_inverted.backup      if @backend_inverted.respond_to? :backup
-      @backend_weights.backup       if @backend_weights.respond_to? :backup
+      # TODO THINK about this. Perhaps the strategies should implement the backend methods?
+      #
+      @backend_weights.backup       if @backend_weights.respond_to? :backup && @weights_strategy.saved?
       @backend_similarity.backup    if @backend_similarity.respond_to? :backup
       @backend_configuration.backup if @backend_configuration.respond_to? :backup
     end
@@ -122,7 +151,9 @@ module Picky
     #
     def restore
       @backend_inverted.restore       if @backend_inverted.respond_to? :restore
-      @backend_weights.restore        if @backend_weights.respond_to? :restore
+      # TODO THINK about this. Perhaps the strategies should implement the backend methods?
+      #
+      @backend_weights.restore        if @backend_weights.respond_to? :restore && @weights_strategy.saved?
       @backend_similarity.restore     if @backend_similarity.respond_to? :restore
       @backend_configuration.restore  if @backend_configuration.respond_to? :restore
     end
@@ -131,7 +162,9 @@ module Picky
     #
     def delete
       @backend_inverted.delete       if @backend_inverted.respond_to? :delete
-      @backend_weights.delete        if @backend_weights.respond_to? :delete
+      # TODO THINK about this. Perhaps the strategies should implement the backend methods?
+      #
+      @backend_weights.delete        if @backend_weights.respond_to? :delete && @weights_strategy.saved?
       @backend_similarity.delete     if @backend_similarity.respond_to? :delete
       @backend_configuration.delete  if @backend_configuration.respond_to? :delete
     end

data/lib/picky/bundle_indexed.rb

@@ -22,24 +22,24 @@ module Picky
     #
     # Returns a (potentially empty) array of ids.
     #
-    def ids sym
-      @inverted[sym] || []
+    def ids sym_or_string
+      @inverted[sym_or_string] || []
     end
 
     # Get a weight for the given symbol.
     #
     # Returns a number, or nil.
     #
-    def weight sym
-      @weights[sym]
+    def weight sym_or_string
+      @weights[sym_or_string]
     end
 
     # Get settings for this bundle.
     #
     # Returns an object.
     #
-    def [] sym
-      @configuration[sym]
+    def [] sym_or_string
+      @configuration[sym_or_string]
     end
 
     # Loads all indexes.
@@ -62,7 +62,9 @@ module Picky
     # Loads the weights index.
     #
     def load_weights
-      self.weights = @backend_weights.load
+      # TODO THINK about this. Perhaps the strategies should implement the backend methods?
+      #
+      self.weights = @backend_weights.load if @weights_strategy.saved?
     end
     # Loads the similarity index.
     #
@@ -92,7 +94,9 @@ module Picky
     # Clears the weights index.
     #
     def clear_weights
-      weights.clear
+      # TODO THINK about this. Perhaps the strategies should implement the backend methods?
+      #
+      weights.clear if @weights_strategy.saved?
     end
     # Clears the similarity index.
     #

data/lib/picky/bundle_indexing.rb

@@ -35,28 +35,6 @@ module Picky
     delegate :clear,
              :to => :inverted
 
-    # "Empties" the index(es) by getting a new empty
-    # internal backend instance.
-    #
-    def empty
-      empty_inverted
-      empty_weights
-      empty_similarity
-      empty_configuration
-    end
-    def empty_inverted
-      @inverted = @backend_inverted.empty
-    end
-    def empty_weights
-      @weights = @backend_weights.empty
-    end
-    def empty_similarity
-      @similarity = @backend_similarity.empty
-    end
-    def empty_configuration
-      @configuration = @backend_configuration.empty
-    end
-
     # Saves the indexes in a dump file.
     #
     def dump
@@ -68,22 +46,24 @@ module Picky
     # Dumps the core index.
     #
     def dump_inverted
-      @backend_inverted.dump self.inverted
+      @backend_inverted.dump @inverted
     end
     # Dumps the weights index.
     #
     def dump_weights
-      @backend_weights.dump self.weights
+      # TODO THINK about this. Perhaps the strategies should implement the backend methods?
+      #
+      @backend_weights.dump @weights if @weights_strategy.saved?
     end
     # Dumps the similarity index.
     #
     def dump_similarity
-      @backend_similarity.dump self.similarity
+      @backend_similarity.dump @similarity
     end
     # Dumps the similarity index.
     #
     def dump_configuration
-      @backend_configuration.dump self.configuration
+      @backend_configuration.dump @configuration
     end
 
   end

data/lib/picky/bundle_realtime.rb

@@ -32,39 +32,49 @@ module Picky
 
     # Returns a reference to the array where the id has been added.
     #
-    # TODO Rename sym.
-    #
-    def add id, sym, where = :unshift
-      ary = @inverted[sym]
+    def add id, str_or_sym, where = :unshift
+      ary = @inverted[str_or_sym]
 
-      syms = @realtime_mapping[id]
-      syms = (@realtime_mapping[id] = []) unless syms # TODO Nicefy.
+      str_or_syms = @realtime_mapping[id]
+      str_or_syms = (@realtime_mapping[id] = []) unless str_or_syms # TODO Nicefy.
 
       # Inverted.
       #
-      ids = if syms.include? sym
-        ids = @inverted[sym]
+      ids = if str_or_syms.include? str_or_sym
+        ids = @inverted[str_or_sym]
         ids.delete  id
         ids.send where, id
       else
-        syms << sym
-        ids = @inverted[sym] ||= []
+        str_or_syms << str_or_sym
+        ids = @inverted[str_or_sym] ||= []
         ids.send where, id
       end
 
       # Weights.
       #
-      @weights[sym] = self.weights_strategy.weight_for ids.size
+      @weights[str_or_sym] = self.weights_strategy.weight_for ids.size
 
       # Similarity.
       #
-      if encoded = self.similarity_strategy.encoded(sym)
+      add_similarity str_or_sym, where
+
+      # Return reference.
+      #
+      ids
+    end
+
+    # Add string/symbol to similarity index.
+    #
+    # TODO Probably where makes no sense here. Should have its own order.
+    #
+    def add_similarity str_or_sym, where = :unshift
+      if encoded = self.similarity_strategy.encoded(str_or_sym)
         similarity = @similarity[encoded] ||= []
-        if similarity.include? sym
-          similarity.delete sym  # Not completely correct, as others will also be affected, but meh.
-          similarity.send where, sym #
+        if similarity.include? str_or_sym
+          similarity.delete str_or_sym  # Not completely correct, as others will also be affected, but meh.
+          similarity.send where, str_or_sym #
         else
-          similarity.send where, sym
+          similarity.send where, str_or_sym
         end
       end
     end

data/lib/picky/category_indexing.rb

@@ -65,13 +65,11 @@ module Picky
     # If we have no explicit source, we'll check the index for one.
     #
     def source
-      (@source && extract_source) || @index.source
+      extract_source || @index.source
     end
     # Extract the actual source if it is wrapped in a time
     # capsule, i.e. a block/lambda.
     #
-    # TODO Extract into module.
-    #
     def extract_source
       @source = @source.respond_to?(:call) ? @source.call : @source
     end

data/lib/picky/category_realtime.rb

@@ -37,7 +37,7 @@ module Picky
     #
     def add_tokenized_token id, text, where = :unshift
       return unless text
-      id   = id.send key_format # TODO Speed this up!
+      id = id.send key_format # TODO Speed this up!
       # text = text.to_sym if @symbols # TODO Symbols.
       exact.add id, text, where
       partial.add_partialized id, text, where

data/lib/picky/character_substituters/west_european.rb

@@ -28,21 +28,21 @@ module Picky
       # (See the associated spec for all examples)
       #
       def substitute text
-        trans = @chars.new(text).normalize(:kd)
+        trans = @chars.new(text).normalize :kd
 
         # Substitute special cases.
         #
-        trans.gsub!('ß', 'ss')
+        trans.gsub! 'ß', 'ss'
 
         # Substitute umlauts (of A,O,U,a,o,u).
         #
-        trans.gsub!(/([AOUaou])\314\210/u, '\1e')
+        trans.gsub! /([AOUaou])\314\210/u, '\1e'
 
         # Get rid of ecutes, graves etc.
         #
         trans.unpack('U*').select { |cp|
           cp < 0x0300 || cp > 0x035F
-        }.pack('U*')
+        }.pack 'U*'
       end
 
       def to_s # :nodoc:

data/lib/picky/generators/partial/infix.rb

@@ -41,53 +41,6 @@ module Picky
           token.each_intoken min, max, &block
         end
 
-        # Generates a partial index from the given inverted index.
-        #
-        def generate_from inverted
-          result = {}
-
-          # Generate for each key token the subtokens.
-          #
-          i = 0
-          j = 0
-          inverted.each_key do |token|
-            i += 1
-            if i == 5000
-              j += 1
-              timed_exclaim %Q{#{"%8i" % (i*j)} generated (current token: "#{token}").}
-              i = 0
-            end
-            generate_for token, inverted, result
-          end
-
-          # Remove duplicate ids.
-          #
-          # THINK If it is unique for a subtoken, it is
-          #       unique for all derived longer tokens.
-          #
-          result.each_value &:uniq!
-
-          result
-        end
-
-        # To each shortened token of :test
-        # :test, :tes, :te, :t
-        # add all ids of :test
-        #
-        # "token" here means just text.
-        #
-        # THINK Could be improved by appending the aforegoing ids?
-        #
-        def generate_for token, inverted, result
-          each_partial token do |intoken|
-            if result[intoken]
-              result[intoken] += inverted[token] # unique
-            else
-              result[intoken] = inverted[token].dup
-            end
-          end
-        end
-
       end
 
     end

data/lib/picky/generators/partial/none.rb

@@ -14,12 +14,6 @@ module Picky
           # yields nothing
         end
 
-        # Returns an empty index.
-        #
-        def generate_from index
-          {}
-        end
-
         # Returns if this strategy's generated file is saved.
         #
         def saved?

data/lib/picky/generators/partial/substring.rb

@@ -78,53 +78,6 @@ module Picky
           @generator.each_subtoken token, &block
         end
 
-        # Generates a partial index from the given inverted index.
-        #
-        def generate_from inverted
-          result = {}
-
-          # Generate for each key token the subtokens.
-          #
-          i = 0
-          j = 0
-          inverted.each_key do |token|
-            i += 1
-            if i == 5000
-              j += 1
-              timed_exclaim %Q{#{"%8i" % (i*j)} generated (current token: "#{token}").}
-              i = 0
-            end
-            generate_for token, inverted, result
-          end
-
-          # Remove duplicate ids.
-          #
-          # THINK If it is unique for a subtoken, it is
-          #       unique for all derived longer tokens.
-          #
-          result.each_value &:uniq!
-
-          result
-        end
-
-        # To each shortened token of :test
-        # :test, :tes, :te, :t
-        # add all ids of :test
-        #
-        # "token" here means just text.
-        #
-        # THINK Could be improved by appending the aforegoing ids?
-        #
-        def generate_for token, inverted, result
-          each_partial token do |subtoken|
-            if result[subtoken]
-              result[subtoken] += inverted[token] # unique
-            else
-              result[subtoken] = inverted[token].dup
-            end
-          end
-        end
-
       end
 
     end

data/lib/picky/generators/similarity/double_metaphone.rb

@@ -14,12 +14,12 @@ module Picky
       #
       class DoubleMetaphone < Phonetic
 
-        # Encodes the given symbol.
+        # Encodes the given string/symbol.
         #
         # Returns a symbol.
         #
-        def encoded sym
-          codes = Text::Metaphone.double_metaphone sym.to_s
+        def encoded str_or_sym
+          codes = Text::Metaphone.double_metaphone str_or_sym.to_s
           codes.first.intern unless codes.empty?
         end
 

data/lib/picky/generators/similarity/metaphone.rb

@@ -14,12 +14,12 @@ module Picky
       #
       class Metaphone < Phonetic
 
-        # Encodes the given symbol.
+        # Encodes the given string/symbol.
         #
         # Returns a symbol.
         #
-        def encoded sym
-          code = Text::Metaphone.metaphone sym.to_s
+        def encoded str_or_sym
+          code = Text::Metaphone.metaphone str_or_sym.to_s
           code.intern if code
         end
 

data/lib/picky/generators/similarity/phonetic.rb

@@ -23,20 +23,23 @@ module Picky
           @amount = amount
         end
 
-        # Generates an index for the given index (in exact index style).
-        #
-        # In the following form:
-        # [:meier, :mueller, :peter, :pater] => { MR: [:meier], MLR: [:mueller], PTR: [:peter, :pater] }
-        #
-        def generate_from inverted
-          hash = hashify inverted.keys
-          sort hash
-        end
+        # # Generates an index for the given index (in exact index style).
+        # #
+        # # In the following form:
+        # # [:meier, :mueller, :peter, :pater] => { MR: [:meier], MLR: [:mueller], PTR: [:peter, :pater] }
+        # #
+        # def generate_from inverted
+        #   hash = hashify inverted.keys
+        #   sort hash
+        # end
 
         protected
 
           # Sorts the index values in place.
           #
+          # TODO Include this again. Sort at the end.
+          #      Or sort when inserting in realtime.
+          #
           def sort hash
             hash.each_pair.each do |code, ary|
               ary.sort_by_levenshtein! code
@@ -45,21 +48,6 @@ module Picky
             hash
           end
 
-          # Hashifies a list of symbols.
-          #
-          # Where:
-          # { encoded_sym => [syms] }
-          #
-          def hashify list
-            list.inject({}) do |total, element|
-              if code = encoded(element)
-                total[code] ||= []
-                total[code] << element
-              end
-              total
-            end
-          end
-
       end
 
     end

data/lib/picky/generators/similarity/soundex.rb

@@ -14,12 +14,12 @@ module Picky
       #
       class Soundex < Phonetic
 
-        # Encodes the given symbol.
+        # Encodes the given string/symbol.
         #
         # Returns a symbol.
         #
-        def encoded sym
-          code = Text::Soundex.soundex sym.to_s
+        def encoded str_or_sym
+          code = Text::Soundex.soundex str_or_sym.to_s
           code.intern if code
         end
 

data/lib/picky/generators/weights/constant.rb

@@ -0,0 +1,46 @@
+module Picky
+
+  module Generators
+
+    module Weights
+
+      # Uses a constant weight.
+      # Default is 0.0.
+      #
+      # Note: This is not saved.
+      #
+      # Examples:
+      #   * Picky::Weights::Constant.new       # Uses 0.0 as a constant weight.
+      #   * Picky::Weights::Constant.new(3.14) # Uses 3.14 as a constant weight.
+      #
+      class Constant < Runtime
+
+        def initialize weight = 0.0
+          @weight = weight
+        end
+
+        # Always returns the constant weight,
+        # except if there are no ids.
+        #
+        def [] _
+
+          @weight
+        end
+
+        # Returns the constant weight,
+        # except if there are no ids.
+        #
+        # Not really used, but is more
+        # correct this way.
+        #
+        def weight_for _
+          @weight
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/picky/generators/weights/dynamic.rb

@@ -0,0 +1,37 @@
+module Picky
+
+  module Generators
+
+    module Weights
+
+      # Uses a dynamic weight.
+      #
+      # Note: This is not saved.
+      #
+      # Examples:
+      #   * Picky::Weights::Dynamic.new do |str_or_sym|
+      #       sym_or_str * length
+      #     end
+      #
+      class Dynamic < Runtime
+
+        # Give it a block that takes a string/symbol
+        # and returns a weight.
+        #
+        def initialize &calculation
+          @calculation = calculation
+        end
+
+        # Calls the block to calculate the weight.
+        #
+        def [] str_or_sym
+          @calculation.call str_or_sym
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/picky/generators/weights/logarithmic.rb

@@ -11,16 +11,6 @@ module Picky
       #
       class Logarithmic < Strategy
 
-        # Generates a partial index from the given inverted index.
-        #
-        def generate_from inverted
-          inverted.inject({}) do |hash, (text, ids)|
-            weight = weight_for ids.size
-            hash[text] ||= weight.round(2) if weight
-            hash
-          end
-        end
-
         # Sets the weight value.
         #
         # If the size is 0 or one, we would get -Infinity or 0.0.

data/lib/picky/generators/weights/runtime.rb

@@ -0,0 +1,41 @@
+module Picky
+
+  module Generators
+    module Weights
+
+      # Is used for runtime-only strategies.
+      #
+      # Note: Pretends to be a backend but
+      #       does nothing at all.
+      #
+      # To override, implement:
+      #   * weight_for(size)    # During indextime. # Probably never used.
+      #   * [] symbol_or_string # During runtime.
+      #
+      # TODO Find a better name.
+      #
+      class Runtime < Strategy
+
+        # It is not saved, by default.
+        #
+        def saved?
+          false
+        end
+
+        # Returns nil.
+        #
+        def weight_for _
+          # Nothing.
+        end
+
+        # Saves nothing by default.
+        #
+        def []= _, _
+
+        end
+
+      end
+    end
+  end
+
+end