picky 2.5.2 → 2.6.0

data/lib/picky/frontend_adapters/rack.rb

@@ -0,0 +1,146 @@
+require 'rack/mount'
+
+module FrontendAdapters
+
+  # TODO Rename to Routing again. Push everything back into appropriate Adapters.
+  #
+  class Rack # :nodoc:all
+
+    #
+    #
+    def reset_routes
+      @routes = ::Rack::Mount::RouteSet.new
+    end
+    def routes
+      @routes || reset_routes
+    end
+    def finalize
+      routes.freeze
+    end
+
+    # Routing simply delegates to the route set to handle a request.
+    #
+    def call env
+      routes.call env
+    end
+
+    # API method.
+    #
+    def route options = {}
+      mappings, route_options = split options
+      mappings.each do |url, query|
+        route_one url, query, route_options
+      end
+    end
+    # Splits the route method options
+    # into real options and route options (/regexp/ => thing or 'some/path' => thing).
+    #
+    def split options
+      mappings      = {}
+      route_options = {}
+      options.each_pair do |key, value|
+        if Regexp === key or String === key
+          mappings[key] = value
+        else
+          route_options[key] = value
+        end
+      end
+      [mappings, route_options]
+    end
+    def route_one url, query, route_options = {}
+      raise RouteTargetNilError.new(url) unless query
+      routes.add_route Adapters::Rack.app_for(query, route_options), default_options(url, route_options), {}, query.to_s
+    end
+    class RouteTargetNilError < StandardError
+      def initialize url
+        @url = url
+      end
+      def to_s
+        "Routing for #{@url.inspect} was defined with a nil target object, i.e. #{@url.inspect} => nil."
+      end
+    end
+    #
+    #
+    def root status
+      answer %r{^/$}, STATUSES[status]
+    end
+    #
+    #
+    def default status
+      answer nil, STATUSES[status]
+    end
+
+
+
+    # TODO Can Rack handle this for me?
+    #
+    # Note: Rack-mount already handles the 404.
+    #
+    STATUSES = {
+      200 => lambda { |_| [200, { 'Content-Type' => 'text/html', 'Content-Length' => '0' }, ['']] },
+      404 => lambda { |_| [404, { 'Content-Type' => 'text/html', 'Content-Length' => '0' }, ['']] }
+    }
+
+    #
+    #
+    def default_options url, route_options = {}
+      url = normalized url
+
+      options = { request_method: 'GET' }.merge route_options
+
+      options[:path_info] = url if url
+
+      options.delete :content_type
+
+      query_params = options.delete :query
+      options[:query_string] = %r{#{generate_query_string(query_params)}} if query_params
+
+      options
+    end
+    #
+    #
+    def generate_query_string query_params
+      raise "At least one query string condition is needed." if query_params.size.zero?
+      raise "Too many query param conditions (only 1 allowed): #{query_params}" if query_params.size > 1
+      k, v = query_params.first
+      "#{k}=#{v}"
+    end
+
+    # Setup a route that answers using the given app.
+    #
+    def answer url = nil, app = nil
+      routes.add_route (app || STATUSES[200]), default_options(url)
+    end
+
+    # Returns a regular expression for the url if it is given a String-like object.
+    #
+    def normalized url
+      url.respond_to?(:to_str) ? %r{#{url}} : url
+    end
+
+    # Returns true if there are no routes defined.
+    #
+    def empty?
+      routes.length.zero?
+    end
+
+    # TODO Beautify. Rewrite!
+    #
+    def to_s
+      max_length = routes.instance_variable_get(:@routes).reduce(0) do |current_max, route|
+        route_length = route.conditions[:path_info].source.to_s.size
+        route_length > current_max ? route_length : current_max
+      end
+      "Note: Anchored (\u2713) regexps are faster, e.g. /\\A.*\\Z/ or /^.*$/.\n\n" +
+      routes.instance_variable_get(:@routes).map do |route|
+        path_info = route.conditions[:path_info]
+        anchored = ::Rack::Mount::Utils.regexp_anchored?(path_info)
+        anchored_ok = anchored ? "\u2713" : " "
+        source = path_info.source
+        "#{anchored_ok}  #{source.ljust(max_length)} => #{route.name}"
+      end.join("\n")
+    end
+
+  end
+
+end

data/lib/picky/generators/aliases.rb

@@ -1,3 +1,3 @@
-Partial    = Internals::Generators::Partial
-Similarity = Internals::Generators::Similarity
-Weights    = Internals::Generators::Weights
+Partial    = Generators::Partial
+Similarity = Generators::Similarity
+Weights    = Generators::Weights

data/lib/picky/generators/base.rb

@@ -0,0 +1,15 @@
+module Generators # :nodoc:all
+
+  # A cache generator holds an index.
+  #
+  class Base
+  
+    attr_reader :index
+  
+    def initialize index
+      @index = index
+    end
+  
+  end
+
+end

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

@@ -0,0 +1,5 @@
+module Generators
+  module Partial
+    Default = Substring.new from: -3, to: -1
+  end
+end

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

@@ -0,0 +1,31 @@
+module Generators
+
+  module Partial
+
+    # Does not generate a partial index.
+    #
+    class None < Strategy
+
+      # Returns an empty index.
+      #
+      def generate_from index
+        {}
+      end
+    
+      # Returns if this strategy's generated file is saved.
+      #
+      def saved?
+        false
+      end
+    
+      # Do not use the partial bundle for getting ids and weights.
+      #
+      def use_exact_for_partial?
+        true
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,25 @@
+module Generators
+
+  module Partial
+
+    # Superclass for partial strategies.
+    #
+    class Strategy < Generators::Strategy
+    
+      # Defines whether to use the exact bundle
+      # instead of the partial one.
+      #
+      # Default is @false@.
+      #
+      # For example: 
+      #  Partial::None.new # Uses the exact index instead of the partial one.
+      #
+      def use_exact_for_partial?
+        false
+      end
+    
+    end
+
+  end
+
+end

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

@@ -0,0 +1,118 @@
+module Generators
+
+  module Partial
+  
+    # Generates the right substrings for use in the substring strategy.
+    #
+    class SubstringGenerator
+    
+      attr_reader :from, :to
+    
+      def initialize from, to
+        @from, @to = from, to
+      
+        if @to.zero?
+          def each_subtoken token, &block
+            token.each_subtoken @from, &block
+          end
+        else
+          def each_subtoken token, &block
+            token[0..@to].intern.each_subtoken @from, &block
+          end
+        end
+      
+      end
+    
+    end
+  
+    # The subtoken partial strategy.
+    #
+    # If given "florian"
+    # it will index "floria", "flori", "flor", "flo", "fl", "f"
+    # (Depending on what the given from value is, the example is with option from: 1)
+    #
+    class Substring < Strategy
+    
+      # The from option signifies where in the symbol it
+      # will start in generating the subtokens.
+      #
+      # Examples:
+      #
+      # With :hello, and to: -1 (default)
+      # * from: 1 # => [:hello, :hell, :hel, :he, :h]
+      # * from: 4 # => [:hello, :hell]
+      #
+      # With :hello, and to: -2
+      # * from: 1 # => [:hell, :hel, :he, :h]
+      # * from: 4 # => [:hell]
+      #
+      def initialize options = {}
+        from     = options[:from] || 1
+        to = options[:to] || -1
+        @generator = SubstringGenerator.new from, to
+      end
+    
+      # Delegator to generator#from.
+      #
+      def from
+        @generator.from
+      end
+    
+      # Delegator to generator#to.
+      #
+      def to
+        @generator.to
+      end
+    
+      # Generates a partial index from the given index.
+      #
+      def generate_from index
+        result = {}
+      
+        # Generate for each key token the subtokens.
+        #
+        i = 0
+        index.each_key do |token|
+          i += 1
+          if i == 5000
+            timed_exclaim "Generating partial tokens for token #{token}. This appears every 5000 tokens."
+            i = 0
+          end
+          generate_for token, index, 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
+    
+      private
+      
+        # 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, index, result
+          @generator.each_subtoken(token) do |subtoken|
+            if result[subtoken]
+              result[subtoken] += index[token] # unique
+            else
+              result[subtoken] = index[token].dup
+            end
+          end
+        end
+      
+    end
+  
+  end
+
+end

data/lib/picky/generators/partial_generator.rb

@@ -0,0 +1,15 @@
+module Generators
+
+  # The partial generator uses a subtoken(downto:1) generator as default.
+  #
+  class PartialGenerator < Base
+  
+    # Generate a partial index based on the given index.
+    #
+    def generate strategy = Partial::Substring.new(from: 1)
+      strategy.generate_from self.index
+    end
+
+  end
+
+end

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

@@ -0,0 +1,7 @@
+module Generators
+  module Similarity
+    # Default is no similarity.
+    #
+    Default = None.new
+  end
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+#
+module Generators
+
+  module Similarity
+
+    # It's actually a combination of double metaphone
+    # and Levenshtein.
+    #
+    # It uses the double metaphone to get similar words
+    # and ranks them using the levenshtein.
+    #
+    class DoubleMetaphone < Phonetic
+
+      # Encodes the given symbol.
+      #
+      # Returns a symbol.
+      #
+      def encoded sym
+        codes = Text::Metaphone.double_metaphone sym.to_s
+        codes.first.to_sym unless codes.empty?
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+#
+module Generators
+
+  module Similarity
+
+    # It's actually a combination of metaphone
+    # and Levenshtein.
+    #
+    # It uses the metaphone to get similar words
+    # and ranks them using the levenshtein.
+    #
+    class Metaphone < Phonetic
+
+      # Encodes the given symbol.
+      #
+      # Returns a symbol.
+      #
+      def encoded sym
+        code = Text::Metaphone.metaphone sym.to_s
+        code.to_sym if code
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,31 @@
+module Generators
+
+  module Similarity
+
+    # Similarity strategy that does nothing.
+    #
+    class None < Strategy
+
+      # Does not encode text. Just returns nil.
+      #
+      def encoded text
+        nil
+      end
+
+      # Returns an empty index.
+      #
+      def generate_from index
+        {}
+      end
+    
+      # Returns if this strategy's generated file is saved.
+      #
+      def saved?
+        false
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+#
+module Generators
+
+  module Similarity
+
+    # It's actually a combination of double metaphone
+    # and Levenshtein.
+    #
+    # It uses the double metaphone to get similar words
+    # and ranks them using the levenshtein.
+    #
+    class Phonetic < Strategy
+
+      attr_reader :amount
+
+      #
+      #
+      def initialize amount = 10
+        raise "In Picky 2.0+, the Similarity::Phonetic has been renamed to Similarity::DoubleMetaphone. Please use that one. Thanks!" if self.class == Phonetic
+        @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 index
+        hash = hashify index.keys
+        sort hash
+      end
+
+      protected
+
+        # Sorts the index values in place.
+        #
+        def sort index
+          index.each_pair.each do |code, ary|
+            ary.sort_by_levenshtein! code
+            ary.slice! amount, ary.size # size is not perfectly correct, but anyway
+          end
+          index
+        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
+
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+#
+module Generators
+
+  module Similarity
+
+    # It's actually a combination of soundex
+    # and Levenshtein.
+    #
+    # It uses the soundex to get similar words
+    # and ranks them using the levenshtein.
+    #
+    class Soundex < Phonetic
+
+      # Encodes the given symbol.
+      #
+      # Returns a symbol.
+      #
+      def encoded sym
+        code = Text::Soundex.soundex sym.to_s
+        code.to_sym if code
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,9 @@
+module Generators
+  module Similarity
+    # Base class for all similarity strategies.
+    #
+    class Strategy < Generators::Strategy
+    
+    end
+  end
+end

data/lib/picky/generators/similarity_generator.rb

@@ -0,0 +1,15 @@
+module Generators
+
+  # Uses no similarity as default.
+  #
+  class SimilarityGenerator < Base
+
+    # Generate a similarity index based on the given index.
+    #
+    def generate strategy = Similarity::None.new
+      strategy.generate_from self.index
+    end
+
+  end
+
+end

data/lib/picky/generators/strategy.rb

@@ -0,0 +1,14 @@
+module Generators
+
+  class Strategy
+  
+    # By default, all caches are saved in a
+    # storage (like a file).
+    #
+    def saved?
+      true
+    end
+  
+  end
+
+end

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

@@ -0,0 +1,7 @@
+module Generators
+  module Weights
+    # Default is Logarithmic.
+    #
+    Default = Logarithmic.new
+  end
+end

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

@@ -0,0 +1,39 @@
+module Generators
+
+  module Weights
+
+    # Uses a logarithmic weight.
+    # If for a key k we have x ids, the weight is:
+    # w(x): log(x)
+    # Special case: If x < 1, then we use 0.
+    #
+    class Logarithmic < Strategy
+
+      # Generates a partial index from the given index.
+      #
+      def generate_from index
+        index.inject({}) do |hash, text_ids|
+          text, ids = *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.
+      # Thus we do not set a value if there is just one. The default, dynamically, is 0.
+      #
+      # BUT: We need the value, even if 0. To designate that there is a weight!
+      #
+      def weight_for amount
+        return 0 if amount < 1
+        Math.log amount
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,9 @@
+module Generators
+  module Weights
+    # Superclass for weighing strategies.
+    #
+    class Strategy < Generators::Strategy
+    
+    end
+  end
+end

data/lib/picky/generators/weights_generator.rb

@@ -0,0 +1,15 @@
+module Generators
+
+  # Uses a logarithmic algorithm as default.
+  #
+  class WeightsGenerator < Base
+
+    # Generate a weights index based on the given index.
+    #
+    def generate strategy = Weights::Logarithmic.new
+      strategy.generate_from self.index
+    end
+
+  end
+
+end