picky 0.0.0 → 0.0.2

data/spec/lib/cacher/weights/logarithmic_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Cacher::Weights::Logarithmic do
+
+  before(:each) do
+    @cacher = Cacher::Weights::Logarithmic.new
+  end
+
+  describe 'generate_from' do
+    it 'should not fail on empties' do
+      @cacher.generate_from({ :key => [] }).should == { :key => 0 }
+    end
+    it 'should round to 2' do
+      @cacher.generate_from({ :key => [1,2,3,4] }).should == { :key => 1.39 }
+    end
+  end
+
+  describe 'weight_for' do
+    it 'should be 0 for 0' do
+      @cacher.weight_for(0).should == 0
+    end
+    it 'should be 0 for 1' do
+      @cacher.weight_for(1).should == 0
+    end
+    it 'should be log(x) for x' do
+      @cacher.weight_for(1234).should == Math.log(1234)
+    end
+  end
+
+end

data/spec/lib/cacher/weights_generator_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Cacher::WeightsGenerator do
+
+  context 'integration' do
+    it 'should generate the correct values' do
+      generator = Cacher::WeightsGenerator.new :a => Array.new(0),
+                                               :b => Array.new(1),
+                                               :c => Array.new(10),
+                                               :d => Array.new(100),
+                                               :e => Array.new(1000)
+
+      result = generator.generate
+
+      result[:c].should be_close 2.3, 0.011
+      result[:d].should be_close 4.6, 0.011
+      result[:e].should be_close 6.9, 0.011
+    end
+  end
+
+end

data/spec/lib/configuration/configuration_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Configuration do
+
+  # describe 'field' do
+  #   it 'should define a new type' do
+  #     Configuration::Field.should_receive(:new).once.with :some_name, :some_options
+  # 
+  #     Configuration.field :some_name, :some_options
+  #   end
+  #   it 'should respect the default' do
+  #     Configuration::Field.should_receive(:new).once.with :some_name, {}
+  # 
+  #     Configuration.field :some_name
+  #   end
+  # end
+  # 
+  # describe 'type' do
+  #   it 'should define a new type' do
+  #     Configuration::Type.should_receive(:new).once.with :some_name, :some_field, :some_other_field
+  # 
+  #     Configuration.type :some_name, :some_field, :some_other_field
+  #   end
+  # end
+  # 
+  # describe 'indexes' do
+  #   it 'should define the indexes and save' do
+  #     indexes = mock :indexes
+  # 
+  #     Configuration::Indexes.should_receive(:new).once.with(:some_types).and_return indexes
+  #     indexes.should_receive(:save).once.with
+  # 
+  #     Configuration.indexes :some_types
+  #   end
+  # end
+
+end

data/spec/lib/configuration/type_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Configuration::Type do
+  
+  before(:each) do
+    @field = stub :field, :type= => nil, :virtual? => false
+    @field.stub! :dup => @field
+    
+    @virtual_field = stub :virtual_field, :type= => nil, :virtual? => true
+    @virtual_field.stub! :dup => @virtual_field
+    @type = Configuration::Type.new :some_name,
+                                    :some_indexing_select,
+                                    @field,
+                                    @virtual_field,
+                                    :after_indexing => "some after indexing",
+                                    :result_type => :some_result_type,
+                                    :weights => :some_weights,
+                                    :ignore_unassigned_tokens => :some_ignore_unassigned_tokens_option,
+                                    :solr => :some_solr_option
+  end
+  
+  describe 'solr_fields' do
+    it 'should return all non-virtual fields' do
+      @type.solr_fields.should == [@field]
+    end
+  end
+  
+  describe 'index_solr' do
+    it 'should get a new solr indexer and start it' do
+      solr = mock :solr
+      Indexers::Solr.should_receive(:new).once.with(@type).and_return solr
+      
+      solr.should_receive(:index).once.with
+      
+      @type.index_solr
+    end
+  end
+  
+  describe 'index' do
+    it 'should index each of the fields' do
+      @field.should_receive(:index).once.with
+      @virtual_field.should_receive(:index).once.with
+      
+      @type.index
+    end
+  end
+  
+end

data/spec/lib/configuration_spec.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Configuration do
+
+  # TODO
+
+end

data/spec/lib/cores_spec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Cores do
+  
+  describe 'number_of_cores' do
+    before(:each) do
+      @linux  = mock :linux,  :null_object => true
+      @darwin = mock :darwin, :null_object => true
+      Cores.stub! :os_to_core_mapping => {
+        'linux'  => @linux,
+        'darwin' => @darwin
+      }
+    end
+    context 'default' do
+      before(:each) do
+        Cores.stub! :platform => 'mswin'
+      end
+      it 'should return 1' do
+        Cores.number_of_cores.should == 1
+      end
+    end
+    context 'osx' do
+      before(:each) do
+        Cores.stub! :platform => 'i386-darwin9.8.0'
+      end
+      it 'should return whatever darwin returns' do
+        @darwin.stub! :call => '1234'
+        
+        Cores.number_of_cores.should == 1234
+      end
+      it 'should call darwin' do
+        @darwin.should_receive(:call).once
+        
+        Cores.number_of_cores
+      end
+      it 'should not call linux' do
+        @linux.should_receive(:call).never
+        
+        Cores.number_of_cores
+      end
+    end
+    context 'linux' do
+      before(:each) do
+        Cores.stub! :platform => 'x86_64-linux'
+      end
+      it 'should return whatever linux returns' do
+        @linux.stub! :call => '1234'
+        
+        Cores.number_of_cores.should == 1234
+      end
+      it 'should call linux' do
+        @linux.should_receive(:call).once
+        
+        Cores.number_of_cores
+      end
+      it 'should not call darwin' do
+        @darwin.should_receive(:call).never
+        
+        Cores.number_of_cores
+      end
+    end
+  end
+  
+end

data/spec/lib/extensions/array_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Array do
+
+  describe 'sort_by_levenshtein!' do
+    it 'should sort right' do
+      ['fish', 'flash', 'flush', 'smooch'].sort_by_levenshtein!(:fush).should == ['fish', 'flush', 'flash', 'smooch']
+    end
+  end
+
+  describe 'random' do
+    it 'should choose one element from the array' do
+      left = [1,2,3]
+      100.times do
+        left.delete [1,2,3].random
+      end
+      left.should be_empty
+    end
+  end
+
+  describe "clustered_uniq" do
+    it "should generate a new array" do
+      ary = [:test1, :test2, :test1]
+      ary.clustered_uniq.object_id.should_not == ary.object_id
+    end
+    it "should not change clusteredly unique arrays" do
+      [:test1, :test2, :test1].clustered_uniq.should == [:test1, :test2, :test1]
+    end
+    it "should not skip interspersed elements" do
+      [:test1, :test1, :test2, :test1].clustered_uniq.should == [:test1, :test2, :test1]
+    end
+    it "should work like uniq if no interspersed elements exist" do
+      [:test1, :test1, :test2, :test2, :test3].clustered_uniq.should == [:test1, :test2, :test3]
+    end
+  end
+
+end

data/spec/lib/extensions/hash_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Hash do
+
+  describe 'dump_to' do
+    it 'should description' do
+
+    end
+  end
+
+end

data/spec/lib/extensions/module_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Module do
+
+  describe 'each_delegate' do
+    before(:each) do
+      @klass = Class.new do
+
+        each_delegate :bli, :bla, :blu, :to => :@some_enumerable
+
+        def initialize some_enumerable
+          @some_enumerable = some_enumerable
+        end
+
+      end
+    end
+    it 'should send each a bli' do
+      bli = stub :bli
+      delegating = @klass.new [bli, bli, bli, bli]
+
+      bli.should_receive(:bli).exactly(4).times
+
+      delegating.bli
+    end
+  end
+
+end

data/spec/lib/extensions/symbol_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Symbol do
+
+  before(:each) do
+    GC.disable
+  end
+  after(:each) do
+    GC.enable
+    GC.start
+  end
+
+  context 'performance' do
+    include Helpers::Measuring
+    it 'should be fast' do
+      s = (((0..9).to_a)*10).to_s.to_sym
+
+      timed do
+        s.subtokens
+      end.should <= 0.003 # was 0.0019
+    end
+  end
+
+  describe "subtokens" do
+    context 'normal symbol' do
+      before(:each) do
+        @sym = :reinke
+      end
+      context 'no downto' do
+        it "should return an array of pieces of the original token, each 1 smaller than the other" do
+          @sym.subtokens.should == [:reinke, :reink, :rein, :rei, :re, :r]
+        end
+      end
+      context 'downto is larger than the symbol' do
+        before(:each) do
+          @downto = 8
+        end
+        it "should return an array of pieces of the original token, each 1 smaller than the other" do
+          @sym.subtokens(@downto).should == [:reinke]
+        end
+      end
+      context 'downto is exactly the same as symbol' do
+        before(:each) do
+          @downto = 6
+        end
+        it "should return an array of pieces of the original token, each 1 smaller than the other" do
+          @sym.subtokens(@downto).should == [:reinke]
+        end
+      end
+      context 'downto is smaller than the length of the symbol' do
+        before(:each) do
+          @downto = 4
+        end
+        it "should return an array of pieces of the original token, each 1 smaller than the other" do
+          @sym.subtokens(@downto).should == [:reinke, :reink, :rein]
+        end
+      end
+      context 'downto is 1' do
+        before(:each) do
+          @downto = 1
+        end
+        it "should return an array of pieces of the original token, each 1 smaller than the other" do
+          @sym.subtokens(@downto).should == [:reinke, :reink, :rein, :rei, :re, :r]
+        end
+      end
+      # context 'downto is 0' do
+      #   before(:each) do
+      #     @downto = 0
+      #   end
+      #   it "should return an array of pieces of the original token, each 1 smaller than the other" do
+      #     @sym.subtokens(@downto).should == [:reinke, :reink, :rein, :rei, :re, :r]
+      #   end
+      # end
+      # context 'downto is less than zero' do
+      #   before(:each) do
+      #     @downto = -2
+      #   end
+      #   it "should return an array of pieces of the original token, each 1 smaller than the other" do
+      #     @sym.subtokens(@downto).should == [:reinke, :reink, :rein, :rei, :re, :r]
+      #   end
+      # end
+    end
+  end
+
+end

data/spec/lib/generator_spec.rb

@@ -0,0 +1,135 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Picky::Generator do
+  
+  describe "main class" do
+    before(:each) do
+      @generator = Picky::Generator.new
+    end
+    
+    describe "generator_for_class" do
+      it "should return me a generator for the given class" do
+        @generator.generator_for_class(Picky::Generator::Project, :some_args).should be_kind_of(Picky::Generator::Project)
+      end
+    end
+    
+    describe "generator_for" do
+      it "should not raise if a generator is available" do
+        lambda { @generator.generator_for('project', 'some_project') }.should_not raise_error
+      end
+      it "should raise if a generator is not available" do
+        lambda { @generator.generator_for('blarf', 'gnorf') }.should raise_error(Picky::NoGeneratorException)
+      end
+      it "should return a generator if it is available" do
+        @generator.generator_for('project', 'some_project').should be_kind_of(Picky::Generator::Project)
+      end
+    end
+    
+    describe "generate" do
+      it "should raise a NoGeneratorException if called with the wrong params" do
+        lambda { @generator.generate(['blarf', 'gnorf']) }.should raise_error(Picky::NoGeneratorException)
+      end
+      it "should not raise on the right params" do
+        @generator.stub! :generator_for_class => stub(:generator, :generate => nil)
+        
+        lambda { @generator.generate(['project', 'some_project']) }.should_not raise_error
+      end
+    end
+  end
+  
+  describe Picky::Generator::Project do
+    
+    before(:each) do
+      @generator = Picky::Generator::Project.new 'some_name', []
+      @generator.stub! :exclaim
+    end
+    
+    context "after initialize" do
+      it "should have a prototype project basedir" do
+        lambda {
+          @generator.prototype_project_basedir
+        }.should_not raise_error
+      end
+      it "should have a name" do
+        @generator.name.should == 'some_name'
+      end
+    end
+    
+    describe "generate" do
+      it "should do things in order" do
+        @generator.should_receive(:create_target_directory).once.ordered
+        @generator.should_receive(:copy_all_files).once.ordered
+        
+        @generator.generate
+      end
+    end
+    
+    describe "create_target_directory" do
+      context "file exists" do
+        before(:each) do
+          File.stub! :exists? => true
+        end
+        it "should just tell the user that" do
+          @generator.stub! :target_directory => :some_target_directory
+          
+          @generator.should_receive(:exists).once.with :some_target_directory
+          
+          @generator.create_target_directory
+        end
+        it "should not make the directory" do
+          FileUtils.should_receive(:mkdir).never
+          
+          @generator.create_target_directory
+        end
+      end
+      context "file does not exist" do
+        before(:each) do
+          File.stub! :exists? => false
+          FileUtils.stub! :mkdir
+        end
+        it "should make the directory" do
+          @generator.stub! :target_directory => :some_target_directory
+          
+          FileUtils.should_receive(:mkdir).once.with :some_target_directory
+          
+          @generator.create_target_directory
+        end
+        it "should tell the user" do
+          @generator.stub! :target_directory => :some_target_directory
+          
+          @generator.should_receive(:created).once.with :some_target_directory
+          
+          @generator.create_target_directory
+        end
+      end
+    end
+    
+    describe "target_filename_for" do
+      it "should return the right filename" do
+        @generator.stub! :target_directory => 'some_target_directory'
+        
+        test_filename = File.expand_path File.join(@generator.prototype_project_basedir, '/some/file/name')
+        
+        @generator.target_filename_for(test_filename).should == 'some_target_directory/some/file/name'
+      end
+    end
+    
+    describe "generate" do
+      it "should copy recursively" do
+        @generator.should_receive(:create_target_directory).once.with
+        @generator.should_receive(:copy_all_files).once.with
+        
+        @generator.generate
+      end
+    end
+    
+    describe "target_directory" do
+      it "should return the right dir name" do
+        @generator.target_directory.should == File.expand_path(File.join(__FILE__, '..', '..', '..', 'some_name'))
+      end
+    end
+    
+  end
+  
+end

data/spec/lib/helpers/cache_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Helpers::Cache do
+  include Helpers::Cache
+
+  describe "#cached" do
+    attr_reader :store, :key
+    before(:each) do
+      @store = {}
+      @key = 'some key'
+    end
+    describe "not yet cached" do
+      it "should cache" do
+        store.should_receive(:[]=).once.with(@key, 'value')
+        cached @store, @key do
+          'value'
+        end
+      end
+    end
+    describe "already cached" do
+      before(:each) do
+        cached @store, @key do
+          'value'
+        end
+      end
+      it "should not cache" do
+        store.should_receive(:[]=).never
+        cached @store, @key do
+          'value'
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/helpers/gc_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Helpers::GC do
+  include Helpers::GC
+
+  before(:each) do
+    ::GC.stub!(:disable)
+    ::GC.stub!(:enable)
+    ::GC.stub!(:start)
+  end
+
+  describe "block calling" do
+    it 'should call the block' do
+      inside_block = mock :inside
+      inside_block.should_receive(:call).once
+
+      disabled do
+        inside_block.call
+      end
+    end
+    it 'should call the block' do
+      inside_block = mock :inside
+      inside_block.should_receive(:call).once
+
+      gc_disabled do
+        inside_block.call
+      end
+    end
+  end
+
+  describe "gc calls" do
+    after(:each) do
+      disabled {}
+    end
+    it 'should disable the garbage collector' do
+      ::GC.should_receive(:disable)
+    end
+    it 'should enable the garbage collector' do
+      ::GC.should_receive(:enable)
+    end
+    it 'should start the garbage collector' do
+      ::GC.should_receive(:start)
+    end
+    it 'should disable the gc, call the block, enable the gc and start the gc' do
+      ::GC.should_receive(:disable).ordered
+      ::GC.should_receive(:enable).ordered
+      ::GC.should_receive(:start).ordered
+    end
+  end
+
+  describe "gc calls" do
+    after(:each) do
+      gc_disabled {}
+    end
+    it 'should disable the garbage collector' do
+      ::GC.should_receive(:disable)
+    end
+    it 'should enable the garbage collector' do
+      ::GC.should_receive(:enable)
+    end
+    it 'should start the garbage collector' do
+      ::GC.should_receive(:start)
+    end
+    it 'should disable the gc, call the block, enable the gc and start the gc' do
+      ::GC.should_receive(:disable).ordered
+      ::GC.should_receive(:enable).ordered
+      ::GC.should_receive(:start).ordered
+    end
+  end
+
+end

data/spec/lib/helpers/measuring_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Helpers::Measuring do
+  include Helpers::Measuring
+
+  describe "#timed" do
+    it "should return some duration" do
+      timed { 1 + 3 }.should_not be_nil
+    end
+  end
+
+  describe "#log_performance" do
+    it "should log" do
+      log_performance('hello') { 10000*10000 }
+    end
+  end
+
+end

data/spec/lib/helpers/search_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe 'Helpers::Search' do
+  include Helpers::Search
+
+  def self.it_should_return_class_for(klass, x)
+    it "should return class #{klass} for #{x} items" do
+      status_class_for(x).should == klass
+    end
+  end
+
+  describe "search_status_class_for" do
+    it_should_return_class_for :none,  0
+    it_should_return_class_for :one,   1
+    it_should_return_class_for :few,   2
+    it_should_return_class_for :few,   3
+    it_should_return_class_for :few,   4
+    it_should_return_class_for :few,   5
+    it_should_return_class_for :few,   6
+    it_should_return_class_for :few,   7
+    it_should_return_class_for :some,  8
+    it_should_return_class_for :some,  9
+    it_should_return_class_for :some, 10
+    it_should_return_class_for :some, 11
+    it_should_return_class_for :some, 12
+    it_should_return_class_for :some, 13
+    it_should_return_class_for :some, 14
+    it_should_return_class_for :some, 15
+    it_should_return_class_for :several, 16
+    it_should_return_class_for :several, 17
+    it_should_return_class_for :several, 18
+    it_should_return_class_for :several, 19
+    it_should_return_class_for :several, 20
+    it_should_return_class_for :several, 21
+    it_should_return_class_for :several, 22
+    it_should_return_class_for :several, 23
+    it_should_return_class_for :several, 24
+    it_should_return_class_for :several, 25
+    it_should_return_class_for :many, 26
+    it_should_return_class_for :many, 27
+    it_should_return_class_for :many, 28
+    it_should_return_class_for :many, 29
+    # etc.
+    it_should_return_class_for :lots, 51
+    # etc.
+    it_should_return_class_for :too_many, 101
+    # etc.
+  end
+
+end