picky 1.4.1 → 1.4.2

data/lib/picky/internals/adapters/rack.rb

@@ -0,0 +1,34 @@
+module Internals
+
+  module Adapters
+
+    # This is an adapter that is plugged into a Rack outlet.
+    #
+    # It looks at what is given to it and generate an appropriate
+    # adapter for it.
+    #
+    # For example, if you give it a query, it will extract the query param etc.
+    # and call search_with_text on it if it is called by Rack.
+    #
+    # Usage:
+    #   Adapters::Rack.app_for(thing, options)
+    #
+    module Rack
+    
+      # Generates the appropriate app for Rack.
+      #
+      @@mapping = {
+        :search_with_text => Query,
+        :parameters       => LiveParameters
+      }
+      def self.app_for thing, options = {}
+        @@mapping.each_pair do |method, adapter|
+          return adapter.new(thing).to_app(options) if thing.respond_to?(method)
+        end
+      end
+    
+    end
+  
+  end
+  
+end

data/lib/picky/{configuration → internals/configuration}/index.rb

@@ -33,7 +33,7 @@ module Configuration # :nodoc:all
       @prepared_index_path ||= "#{index_directory}/prepared_#{category_name}_index"
     end
     def prepared_index_file &block
-      @prepared_index_file ||= ::Index::File::Text.new prepared_index_path
+      @prepared_index_file ||= Internals::Index::File::Text.new prepared_index_path
       @prepared_index_file.open_for_indexing &block
     end
     
@@ -41,8 +41,14 @@ module Configuration # :nodoc:all
     #   @file_name ||= "#{@index_name}_#{@category_name}"
     # end
     
+    # Identifier for internal use.
+    #
     def identifier
-      @identifier ||= "#{index_name} #{category_name}"
+      @identifier ||= "#{index_name}:#{category_name}"
+    end
+    
+    def to_s
+      "#{index_name} #{category_name}"
     end
     
     def self.index_root

data/lib/picky/internals/frontend_adapters/rack.rb

@@ -0,0 +1,154 @@
+require 'rack/mount'
+
+module Internals
+
+  module FrontendAdapters
+
+    # TODO Rename to Routing again. Push everything back into appropriate Adapters.
+    #
+    class Rack # :nodoc:all
+  
+      @@defaults = {
+        query_key:    'query'.freeze,
+        offset_key:   'offset'.freeze,
+        content_type: 'application/octet-stream'.freeze # TODO Wrong.
+      }
+  
+      def initialize
+        @defaults = @@defaults.dup
+      end
+  
+      # 
+      #
+      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 Internals::Adapters::Rack.app_for(query, route_options), default_options(url, route_options)
+      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.
+      #
+      def to_s
+        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" : " "
+          "#{anchored_ok}  #{path_info.source}"
+        end.join "\n"
+      end
+  
+    end
+  
+  end
+  
+end

data/lib/picky/internals/generators/base.rb

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

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

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

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

@@ -0,0 +1,35 @@
+module Internals
+
+  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
+  
+end

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

@@ -0,0 +1,29 @@
+module Internals
+
+  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
+
+end

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

@@ -0,0 +1,122 @@
+module Internals
+
+  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
+  
+end

data/lib/picky/internals/generators/partial_generator.rb

@@ -0,0 +1,19 @@
+module Internals
+
+  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
+  
+end

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

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

data/lib/picky/internals/generators/similarity/double_levenshtone.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+#
+module Internals
+
+  module Generators
+
+    module Similarity
+
+      # DoubleLevensthone means that it's a combination of
+      # * DoubleMetaphone
+      # and
+      # * Levenshtein
+      # :)
+      #
+      class DoubleLevenshtone < Strategy
+
+        attr_reader :amount
+
+        #
+        #
+        def initialize amount = 10
+          @amount = amount
+        end
+
+        # 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
+
+        # 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
+
+        private
+
+          # 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
+    
+      # ... aka Phonetic.
+      #
+      Phonetic = DoubleLevenshtone
+
+    end
+
+  end
+  
+end

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

@@ -0,0 +1,35 @@
+module Internals
+
+  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
+  
+end

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

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

data/lib/picky/internals/generators/similarity_generator.rb

@@ -0,0 +1,19 @@
+module Internals
+
+  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
+  
+end

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

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

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

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