picky 2.0.0.pre2 → 2.0.0.pre3

data/lib/picky/internals/query/indexes.rb

@@ -17,8 +17,7 @@ module Internals
 
       # Creates a new Query::Indexes.
       #
-      # Its job is to generate all possible combinations, but also
-      # checking whether the query indexes are all of the same type.
+      # Its job is to generate all possible combinations.
       # Note: We cannot mix memory and redis indexes just yet.
       #
       def initialize *index_definitions, combinations_type
@@ -29,32 +28,38 @@ module Internals
       # Returns a number of possible allocations for the given tokens.
       #
       def allocations_for tokens
-        Allocations.new(indexes.inject([]) do |previous_allocations, index|
-          # Expand the combinations.
-          #
-          possible_combinations = tokens.possible_combinations_in index
+        Allocations.new allocations_ary_for(tokens)
+      end
+      def allocations_ary_for tokens
+        indexes.inject([]) do |allocations, index|
+          allocations + allocation_for(tokens, index)
+        end
+      end
+      def allocation_for tokens, index
+        # Expand the combinations.
+        #
+        possible_combinations = tokens.possible_combinations_in index
 
-          # Optimization for ignoring tokens that allocate to nothing and
-          # can be ignored.
-          # For example in a special search, where "florian" is not
-          # mapped to any category.
-          #
-          possible_combinations.compact!
+        # Optimization for ignoring tokens that allocate to nothing and
+        # can be ignored.
+        # For example in a special search, where "florian" is not
+        # mapped to any category.
+        #
+        possible_combinations.compact!
 
-          # Generate all possible combinations.
-          #
-          expanded_combinations = expand_combinations_from possible_combinations
+        # Generate all possible combinations.
+        #
+        expanded_combinations = expand_combinations_from possible_combinations
 
-          # If there are none, try the next allocation.
-          #
-          next previous_allocations unless expanded_combinations
+        # If there are none, try the next allocation.
+        #
+        return [] unless expanded_combinations
 
-          # Add the wrapped possible allocations to the ones we already have.
-          #
-          previous_allocations + expanded_combinations.map! do |expanded_combination|
-            @combinations_type.new(expanded_combination).pack_into_allocation(index.result_identifier) # TODO Do not extract result_identifier. Remove pack_into_allocation.
-          end
-        end)
+        # Add the wrapped possible allocations to the ones we already have.
+        #
+        expanded_combinations.map! do |expanded_combination|
+          Allocation.new @combinations_type.new(expanded_combination), index.result_identifier # TODO Do not extract result_identifier.
+        end
       end
 
       # This is the core of the search engine.

data/lib/picky/internals/query/token.rb

@@ -1,7 +1,7 @@
 module Internals
 
   module Query
-  
+
     # This is a query token. Together with other tokens it makes up a query.
     #
     # It remembers the original form, and and a normalized form.
@@ -95,7 +95,7 @@ module Internals
       def remove_illegals
         @text.gsub! @@illegals, '' unless @text.blank?
       end
-    
+
       # Visitor for tokenizer.
       #
       # TODO Rewrite!!!
@@ -115,10 +115,10 @@ module Internals
 
       # Returns an array of possible combinations.
       #
-      def possible_combinations_in type
-        type.possible_combinations self
+      def possible_combinations_in index
+        index.possible_combinations self
       end
-    
+
       # Returns a token with the next similar text.
       #
       # TODO Rewrite this. It is hard to understand. Also spec performance.
@@ -168,19 +168,19 @@ module Internals
       def to_solr
         blank? ? '' : (to_s + @@solr_fuzzy_mapping[@text.size].to_s)
       end
-    
+
       #
       #
       def to_result
         [@original, @text]
       end
-    
+
       # Internal identifier.
       #
       def identifier
         "#{similar?? :similarity : :index}:#{@text}"
       end
-    
+
       # Displays the qualifier text and the text, joined.
       #
       # e.g. name:meier
@@ -188,9 +188,9 @@ module Internals
       def to_s
         [@qualifier, @text].compact.join ':'
       end
-    
+
       private
-      
+
         # Splits text into a qualifier and text.
         #
         # Returns [qualifier, text].
@@ -205,7 +205,7 @@ module Internals
         end
 
     end
-    
+
   end
-  
+
 end

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

@@ -20,7 +20,7 @@ Removes chars after split: #{@removes_characters_after_splitting_regexp ? "/#{@r
 Normalizes words:          #{@normalizes_words_regexp_replaces ? @normalizes_words_regexp_replaces : '-'}
 Rejects tokens?            #{reject_condition_location ? "Yes, see line #{reject_condition_location} in app/application.rb" : '-'}
 Substitutes chars?         #{@substituter ? "Yes, using #{@substituter}." : '-' }
-TOKENIZER
+        TOKENIZER
       end
 
       # Stopwords.

data/lib/picky/loader.rb

@@ -22,9 +22,6 @@ module Loader # :nodoc:all
     load __FILE__
   end
 
-  def self.require_relative filename
-    require File.join(File.dirname(__FILE__), filename)
-  end
   def self.load_relative filename_without_rb
     load File.join(File.dirname(__FILE__), "#{filename_without_rb}.rb")
   end
@@ -136,7 +133,10 @@ module Loader # :nodoc:all
     #
     load_internals 'generators/similarity/strategy'
     load_internals 'generators/similarity/none'
-    load_internals 'generators/similarity/double_levenshtone'
+    load_internals 'generators/similarity/phonetic'
+    load_internals 'generators/similarity/metaphone'
+    load_internals 'generators/similarity/double_metaphone'
+    load_internals 'generators/similarity/soundex'
     load_internals 'generators/similarity/default'
 
     # Index generators.

data/lib/picky/sources/couch.rb

@@ -26,19 +26,17 @@ module Sources
       check_gem
 
       Hash === options && options[:url] || raise_no_db_given(category_names)
+
       @db = RestClient::Resource.new options.delete(:url), options
+
+      key_format   = options.delete :key_format
+      @key_format  = key_format && key_format.to_sym || :to_sym
     end
 
     def to_s
       self.class.name
     end
 
-    # Default key format method for couch DB is to_sym.
-    #
-    def key_format
-      :to_sym
-    end
-
     # Tries to require the rest_client gem.
     #
     def check_gem # :nodoc:

data/lib/picky/sources/delicious.rb

@@ -25,7 +25,7 @@ module Sources
     end
 
     def to_s
-      self.class.name
+      "#{self.class.name}(#{@username})"
     end
 
     # Harvests the data to index.

data/spec/lib/analyzer_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Analyzer do
+  
+  let(:analyzer) { described_class.new }
+  
+  context 'after initialize' do
+    it 'sets the comments' do
+      analyzer.comments.should == []
+    end
+    it 'sets the analysis' do
+      analyzer.analysis.should == {}
+    end
+  end
+  
+end

data/spec/lib/application_spec.rb

@@ -42,13 +42,15 @@ describe Application do
           books_index = Index::Memory.new :books,
                               Sources::DB.new('SELECT id, title, author, isbn13 as isbn FROM books', :file => 'app/db.yml')
           books_index.define_category :title,
-                                      similarity: Similarity::DoubleLevenshtone.new(3) # Up to three similar title word indexed.
-          books_index.define_category :author
+                                      similarity: Similarity::DoubleMetaphone.new(3) # Up to three similar title word indexed.
+          books_index.define_category :author,
+                                      similarity: Similarity::Soundex.new(2)
           books_index.define_category :isbn,
                                       partial: Partial::None.new # Partially searching on an ISBN makes not much sense.
           
           geo_index = Index::Memory.new :geo, Sources::CSV.new(:location, :north, :east, file: 'data/ch.csv', col_sep: ',') do
-            category        :location
+            category        :location,
+                            similarity: Similarity::Metaphone.new(4)
             ranged_category :north1, 1, precision: 3, from: :north
             ranged_category :east1,  1, precision: 3, from: :east
           end
@@ -77,6 +79,14 @@ describe Application do
     end
   end
   
+  describe 'check' do
+    it 'does something' do
+      Application.should_receive(:warn).once.with "\nWARNING: No routes defined for application configuration in Class.\n\n"
+      
+      Application.check
+    end
+  end
+  
   describe 'delegation' do
     it "should delegate route" do
       Application.rack_adapter.should_receive(:route).once.with :path => :query

data/spec/lib/bundling_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe 'bundling' do
+  
+  # TODO
+  #
+  # context 'loading bundler fails' do
+  #   before(:each) do
+  #     Kernel.should_receive(:require).once.with('bundler').and_raise LoadError.new
+  #   end
+  #   it 'does something' do
+  #     Kernel.should_receive(:require).once.with 'rubygems'
+  #     Kernel.should_receive(:require).once.with 'bundler'
+  #     
+  #     load File.expand_path '../../../lib/bundling.rb', __FILE__
+  #   end
+  # end
+  
+end

data/spec/lib/character_substituters/west_european_spec.rb

@@ -3,8 +3,8 @@
 require 'spec_helper'
 
 describe CharacterSubstituters do
-  before(:each) do
-    @substituter = CharacterSubstituters::WestEuropean.new
+  before(:all) do
+    @substituter = CharacterSubstituters::WestEuropean.new.tap { |s| s.substitute '' }
   end
 
   # A bit of metaprogramming to help with the myriads of its.
@@ -33,6 +33,12 @@ describe CharacterSubstituters do
       result.should < 0.00015
     end
   end
+  
+  describe 'to_s' do
+    it 'outputs correctly' do
+      @substituter.to_s.should == 'CharacterSubstituters::WestEuropean'
+    end
+  end
 
   describe "normal characters" do
     it_should_not_substitute('abcdefghijklmnopqrstuvwxyz1234567890')

data/spec/lib/cli_spec.rb

@@ -10,52 +10,80 @@ require File.expand_path '../../../lib/picky/cli', __FILE__
 #
 describe Picky::CLI do
   
+  describe '.mapping' do
+    it 'returns the right mapping' do
+      Picky::CLI.mapping.should == {
+        :generate => [Picky::CLI::Generate, :"{sinatra_client,unicorn_server,empty_unicorn_server}", :app_directory_name],
+        :help     => [Picky::CLI::Help],
+        :stats    => [Picky::CLI::Statistics, :"logfile (e.g. log/search.log)", "port (default: 4567)"],
+        :live     => [Picky::CLI::Live, "host:port/path (default: localhost:8080/admin)", "port (default: 4568)"]
+      }
+    end
+  end
+  
   describe 'instance' do
-    before(:each) do
-      @cli = Picky::CLI.new
+    let(:cli) { described_class.new }
+    describe 'execute' do
+      it 'calls generate correctly' do
+        Kernel.should_receive(:system).once.with 'picky-generate one two three'
+        
+        cli.execute 'generate', 'one', 'two', 'three'
+      end
+      it 'calls help correctly' do
+        Kernel.should_receive(:puts).once.with <<-HELP
+Possible commands:
+  picky generate {sinatra_client,unicorn_server,empty_unicorn_server} app_directory_name
+  picky help 
+  picky stats logfile (e.g. log/search.log) [port (default: 4567)]
+  picky live [host:port/path (default: localhost:8080/admin)] [port (default: 4568)]
+HELP
+        cli.execute 'help'
+      end
+      # it 'calls live and it does not fail' do
+      #   cli.execute 'live'
+      # end
+      # it 'calls stats and it does not fail' do
+      #   cli.execute 'stats', 'some/log/file.log'
+      # end
     end
     describe 'executor_class_for' do
       it 'returns Help by default' do
-        @cli.executor_class_for.should == [Picky::CLI::Help]
+        cli.executor_class_for.should == [Picky::CLI::Help]
       end
       it 'returns Generator for generate' do
-        @cli.executor_class_for(:generate).should == [Picky::CLI::Generate, :'{sinatra_client,unicorn_server,empty_unicorn_server}', :"app_directory_name"]
+        cli.executor_class_for(:generate).should == [Picky::CLI::Generate, :'{sinatra_client,unicorn_server,empty_unicorn_server}', :"app_directory_name"]
       end
       it 'returns Help for help' do
-        @cli.executor_class_for(:help).should == [Picky::CLI::Help]
+        cli.executor_class_for(:help).should == [Picky::CLI::Help]
       end
       it 'returns Statistics for stats' do
-        @cli.executor_class_for(:stats).should == [Picky::CLI::Statistics, :"logfile (e.g. log/search.log)", "port (default: 4567)"]
+        cli.executor_class_for(:stats).should == [Picky::CLI::Statistics, :"logfile (e.g. log/search.log)", "port (default: 4567)"]
       end
       it 'returns Live for live' do
-        @cli.executor_class_for(:live).should == [Picky::CLI::Live, "host:port/path (default: localhost:8080/admin)", "port (default: 4568)"]
+        cli.executor_class_for(:live).should == [Picky::CLI::Live, "host:port/path (default: localhost:8080/admin)", "port (default: 4568)"]
       end
       it 'returns Help for silly input' do
-        @cli.executor_class_for(:gagagagagagaga).should == [Picky::CLI::Help]
+        cli.executor_class_for(:gagagagagagaga).should == [Picky::CLI::Help]
       end
     end
   end
   
   describe Picky::CLI::Live do
-    before(:each) do
-      @cli = Picky::CLI::Live.new
-    end
+    let(:executor) { described_class.new }
   end
   
   describe Picky::CLI::Base do
-    before(:each) do
-      @executor = Picky::CLI::Base.new
-    end
+    let(:executor) { described_class.new }
     describe 'usage' do
       it 'calls puts with an usage' do
-        @executor.should_receive(:puts).once.with "Usage\n  picky some_name param1 [param2]"
+        executor.should_receive(:puts).once.with "Usage\n  picky some_name param1 [param2]"
         
-        @executor.usage :some_name, [:param1, 'param2']
+        executor.usage :some_name, [:param1, 'param2']
       end
     end
     describe 'params_to_s' do
       it 'returns the right string' do
-        @executor.params_to_s([:param1, 'param2']).should == 'param1 [param2]'
+        executor.params_to_s([:param1, 'param2']).should == 'param1 [param2]'
       end
     end
   end

data/spec/lib/index/redis_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Index::Redis do
+  
+  let(:some_source) { stub :source, :harvest => nil }
+  
+  describe 'initialize' do
+    it 'works' do
+      described_class.new :some_name, some_source
+    end
+  end
+  
+end

data/spec/lib/internals/adapters/rack/live_parameters_spec.rb

@@ -4,17 +4,22 @@ require 'spec_helper'
 
 describe Internals::Adapters::Rack::LiveParameters do
   
-  before(:each) do
-    @live_parameters = stub :live_parameters
-    @adapter         = described_class.new @live_parameters
-  end
+  let(:live_parameters) { stub :live_parameters }
+  let(:adapter) { described_class.new live_parameters }
   
   describe 'to_app' do
     it 'works' do
-      lambda { @adapter.to_app }.should_not raise_error
+      lambda { adapter.to_app }.should_not raise_error
     end
     it 'returns the right thing' do
-      @adapter.to_app.should respond_to(:call)
+      adapter.to_app.should respond_to(:call)
+    end
+    it 'returned lambda should call parameters on the live parameters' do
+      env = { 'rack.input' => 'some input' }
+      
+      live_parameters.should_receive(:parameters).once.with({})
+      
+      adapter.to_app.call env
     end
   end
   

data/spec/lib/internals/frontend_adapters/rack_spec.rb

@@ -52,6 +52,11 @@ describe Internals::FrontendAdapters::Rack do
       it 'returns the right answer' do
         @rack_adapter.empty?.should == false
       end
+      describe 'to_s' do
+        it 'outputs correctly' do
+          @rack_adapter.to_s.should == "Note: Anchored (✓) regexps are faster, e.g. /\\A.*\\Z/ or /^.*$/.\n\n   something => Search()"
+        end
+      end
     end
   end
   
@@ -136,6 +141,14 @@ describe Internals::FrontendAdapters::Rack do
     end
   end
   
+  describe 'to_s' do
+    context 'no routes' do
+      it 'outputs correctly' do
+        @rack_adapter.to_s.should == "Note: Anchored (✓) regexps are faster, e.g. /\\A.*\\Z/ or /^.*$/.\n\n"
+      end
+    end
+  end
+  
   context 'stubbed routes' do
     before(:each) do
       @routes = stub :routes
@@ -216,6 +229,15 @@ describe Internals::FrontendAdapters::Rack do
       end
     end
     
+    describe 'STATUSES' do
+      it 'is a lambda' do
+        Internals::FrontendAdapters::Rack::STATUSES[200].respond_to?(:call).should == true
+      end
+      it 'is a lambda' do
+        Internals::FrontendAdapters::Rack::STATUSES[404].respond_to?(:call).should == true
+      end
+    end
+    
     describe 'root' do
       it 'should call answer' do
         @rack_adapter.should_receive(:answer).once.with %r{^/$}, Internals::FrontendAdapters::Rack::STATUSES[200]

data/spec/lib/internals/generators/similarity/{double_levenshtone_spec.rb → double_metaphone_spec.rb}

@@ -2,7 +2,7 @@
 #
 require 'spec_helper'
 
-describe Internals::Generators::Similarity::DoubleLevenshtone do
+describe Internals::Generators::Similarity::DoubleMetaphone do
 
   before(:each) do
     @similarity = described_class.new
@@ -56,11 +56,5 @@ describe Internals::Generators::Similarity::DoubleLevenshtone do
       index[code].should == [:mair, :maier, :meier, :meira, :mairai]
     end
   end
-  
-  context "alias" do
-    it "works also with Phonetic" do
-      lambda { Internals::Generators::Similarity::Phonetic.new(1) }.should_not raise_error
-    end
-  end
 
 end

data/spec/lib/internals/generators/similarity/metaphone_spec.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Internals::Generators::Similarity::Metaphone do
+
+  before(:each) do
+    @similarity = described_class.new
+  end
+
+  def self.it_should_encode text, expected
+    it "should encode #{text.inspect} correctly" do
+      @similarity.encoded(text).should == expected
+    end
+  end
+  def self.it_should_generate_from index, expected
+    it "should generate #{expected.inspect} correctly from #{index.inspect}" do
+      @similarity.generate_from(index).should == expected
+    end
+  end
+
+  it_should_encode :meier,       :MR
+  it_should_encode :grossberger, :KRSBRJR
+  it_should_encode :hadelbla,    :HTLBL
+
+  it_should_generate_from({}, {})
+  it_should_generate_from({ :maier => nil, :meier => nil }, :MR => [:maier, :meier]) # should be correctly ordered
+  it_should_generate_from({ :maier => nil, :meier => nil, :hallaballa => nil }, :MR => [:maier, :meier], :HLBL => [:hallaballa])
+  it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :SSN => [:susan, :susanne], :BRTRR => [:bruderer])
+
+  describe 'with reduced amount' do
+    before(:each) do
+      @similarity = described_class.new(1)
+    end
+    it_should_generate_from({ :maier => nil, :meier => nil }, :MR => [:maier])
+    it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :SSN => [:susan], :BRTRR => [:bruderer])
+  end
+
+  describe 'hashify' do
+    it 'should turn an empty list into an empty hash' do
+      @similarity.send(:hashify, []).should == {}
+    end
+    it 'should turn the list into an unordered similarity' do
+      @similarity.send(:hashify, [:meier, :maier]).should == { :MR => [:meier, :maier] }
+    end
+    it 'should turn the list into a encoded hash' do
+      @similarity.send(:hashify, [:meier, :maier, :peter]).should == { :MR => [:meier, :maier], :PTR => [:peter] }
+    end
+  end
+
+  context 'integration' do
+    it 'should return the right ordered array' do
+      index = @similarity.generate_from :meier => nil, :maier => nil, :mairai => nil, :mair => nil, :meira => nil
+      code  = @similarity.encoded :maier
+
+      index[code].should == [:mair, :maier, :meier, :meira, :mairai]
+    end
+  end
+
+end

data/spec/lib/internals/generators/similarity/phonetic_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Internals::Generators::Similarity::Phonetic do
+
+  it 'raises if you try to use Phonetic directly' do
+    expect {
+      described_class.new
+    }.to raise_error("From Picky 2.0 on you need to use the DoubleMetaphone similarity instead of the Phonetic similarity.")
+  end
+
+end

data/spec/lib/internals/generators/similarity/soundex_spec.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Internals::Generators::Similarity::Soundex do
+
+  before(:each) do
+    @similarity = described_class.new
+  end
+
+  def self.it_should_encode text, expected
+    it "should encode #{text.inspect} correctly" do
+      @similarity.encoded(text).should == expected
+    end
+  end
+  def self.it_should_generate_from index, expected
+    it "should generate #{expected.inspect} correctly from #{index.inspect}" do
+      @similarity.generate_from(index).should == expected
+    end
+  end
+
+  it_should_encode :meier,       :M600
+  it_should_encode :grossberger, :G621
+  it_should_encode :hadelbla,    :H341
+
+  it_should_generate_from({}, {})
+  it_should_generate_from({ :maier => nil, :meier => nil }, :M600 => [:maier, :meier]) # should be correctly ordered
+  it_should_generate_from({ :maier => nil, :meier => nil, :hallaballa => nil }, :M600 => [:maier, :meier], :H414 => [:hallaballa])
+  it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :S250 => [:susan, :susanne], :B636 => [:bruderer])
+
+  describe 'with reduced amount' do
+    before(:each) do
+      @similarity = described_class.new(1)
+    end
+    it_should_generate_from({ :maier => nil, :meier => nil }, :M600 => [:maier])
+    it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :S250 => [:susan], :B636 => [:bruderer])
+  end
+
+  describe 'hashify' do
+    it 'should turn an empty list into an empty hash' do
+      @similarity.send(:hashify, []).should == {}
+    end
+    it 'should turn the list into an unordered similarity' do
+      @similarity.send(:hashify, [:meier, :maier]).should == { :M600 => [:meier, :maier] }
+    end
+    it 'should turn the list into a encoded hash' do
+      @similarity.send(:hashify, [:meier, :maier, :peter]).should == { :M600 => [:meier, :maier], :P360 => [:peter] }
+    end
+  end
+
+  context 'integration' do
+    it 'should return the right ordered array' do
+      index = @similarity.generate_from :meier => nil, :maier => nil, :mairai => nil, :mair => nil, :meira => nil
+      code  = @similarity.encoded :maier
+
+      index[code].should == [:mair, :maier, :meier, :meira, :mairai]
+    end
+  end
+
+end

data/spec/lib/internals/generators/similarity_generator_spec.rb

@@ -15,7 +15,7 @@ describe Internals::Generators::SimilarityGenerator do
                                                   :meyer => nil,
                                                   :peter => nil
 
-      generator.generate(Internals::Generators::Similarity::DoubleLevenshtone.new).should == { :MR => [:meier, :maier, :mayer, :meyer], :PTR => [:peter] }
+      generator.generate(Internals::Generators::Similarity::DoubleMetaphone.new).should == { :MR => [:meier, :maier, :mayer, :meyer], :PTR => [:peter] }
     end
   end