CloudSesame 0.6.4 → 0.6.5

data/lib/cloud_sesame/query/dsl/scope_accessors.rb

@@ -8,7 +8,7 @@ module CloudSesame
 
 					defined_scopes = _scope.context[:scopes]
 					if defined_scopes && (block = defined_scopes[name.to_sym])
-						instance_exec *args, &block
+						instance_exec(*args, &block)
 						_return
 					else
 						raise Error::ScopeNotDefined

data/lib/cloud_sesame/query/node/fuzziness.rb

@@ -3,6 +3,8 @@ module CloudSesame
     module Node
       class Fuzziness
 
+        EXCLUDING_TERMS = /^\-/
+
         def initialize(&block)
 
           # default fuzziness
@@ -10,7 +12,7 @@ module CloudSesame
           @min_char_size = 6
           @fuzzy_percent = 0.17
 
-          instance_eval &block if block_given?
+          instance_eval(&block) if block_given?
         end
 
         def max_fuzziness(int)
@@ -25,32 +27,28 @@ module CloudSesame
           @fuzzy_percent = float.to_f
         end
 
-        def parse(string)
-          join_by_and each_with(string) { |word| fuzziness word }
+        def compile(string)
+          "(#{ each_word_in(string) { |word| fuzziness(word) }.compact.join('+') })"
         end
 
         private
 
-        def each_with(string, &block)
-          string.split(' ').map &block
+        def each_word_in(string, &block)
+          string.split(' ').map(&block)
         end
 
         def fuzziness(word)
-          if word.length >= @min_char_size && !excluding_term?(word)
-            fuzziness = (word.length * @fuzzy_percent).round
+          if (length = word.length) >= @min_char_size && !excluding_term?(word)
+            fuzziness = (length * @fuzzy_percent).round
             fuzziness = [fuzziness, @max_fuzziness].min
-            "#{word}~#{fuzziness}"
+            "#{ word }~#{ fuzziness }"
           else
             word
           end
         end
 
-        def join_by_and(args = [])
-          (args = args.compact).size > 1 ? "(#{ args.join('+') })" : args[0]
-        end
-
         def excluding_term?(word)
-          !!word.match(/^\-/)
+          !!(EXCLUDING_TERMS =~ word)
         end
 
       end

data/lib/cloud_sesame/query/node/query.rb

@@ -10,24 +10,23 @@ module CloudSesame
 				end
 
 				def compile
-					compiled = [query]
-					compiled << fuzziness if context[:fuzziness]
-					compiled << sloppiness if context[:sloppiness]
-					{ query: join_by_or(compiled) }
+					{ query: "(#{
+							query
+						})#{
+							'|' << fuzziness.compile(query) if fuzziness
+						}#{
+							'|' << sloppiness.compile(query) if sloppiness
+						}" }
 				end
 
 				private
 
 				def fuzziness
-					context[:fuzziness] && query && !query.empty? ? context[:fuzziness].parse(query) : nil
+					context[:fuzziness]
 				end
 
 				def sloppiness
-					context[:sloppiness] && query && query.include?(' ') ? "\"#{ query }\"~#{ context[:sloppiness] }" : nil
-				end
-
-				def join_by_or(args = [])
-					(args = args.compact).size > 1 ? "(#{ args.join('|') })" : args[0]
+					context[:sloppiness]
 				end
 
 			end

data/lib/cloud_sesame/query/node/request.rb

@@ -51,8 +51,8 @@ module CloudSesame
 						page,
 						sort,
 						return_field
-					].each_with_object({}) do |node, compiled|
-						compiled.merge!(node.compile || {})
+					].each_with_object({}) do |node, object|
+						object.merge!(node.compile || {})
 					end
 
 					if compiled[:filter_query].empty?

data/lib/cloud_sesame/query/node/sloppiness.rb

@@ -0,0 +1,23 @@
+module CloudSesame
+  module Query
+    module Node
+      class Sloppiness
+
+        def initialize(value)
+          @value = value.to_i
+        end
+
+        def compile(string)
+          "\"#{ string }\"~#{ @value }" if more_than_one_word?(string)
+        end
+
+        private
+
+        def more_than_one_word?(string)
+          string.include?(' ')
+        end
+
+      end
+    end
+  end
+end

data/spec/cloud_sesame/config/credential_spec.rb

@@ -0,0 +1,76 @@
+module CloudSesame
+	module Config
+		describe Credential do
+
+			describe '#initialize' do
+				it 'should accept access_key_id' do
+					credential = Credential.new(access_key_id: 123)
+					expect(credential.to_hash[:access_key_id]).to eq 123
+				end
+				it 'should accept access_key as an alias for access_key_id' do
+					credential = Credential.new(access_key: 123)
+					expect(credential.to_hash[:access_key_id]).to eq 123
+				end
+				it 'should accept secret_access_key' do
+					credential = Credential.new(secret_access_key: 'secret')
+					expect(credential.to_hash[:secret_access_key]).to eq 'secret'
+				end
+				it 'should accept secret_key as an alias for secret_access_key' do
+					credential = Credential.new(secret_key: 'secret')
+					expect(credential.to_hash[:secret_access_key]).to eq 'secret'
+				end
+			end
+
+			describe 'access_key_id' do
+				context 'getter' do
+					subject { Credential.new(access_key: 123) }
+					it 'should be defined' do
+						expect(subject).to respond_to(:access_key_id)
+						expect(subject.access_key_id).to eq 123
+					end
+					it 'should have an alias getter defined' do
+						expect(subject).to respond_to(:access_key)
+						expect(subject.access_key).to eq 123
+					end
+				end
+				context 'writer' do
+					let(:attributes) { subject.instance_variable_get(:@attributes) }
+					it 'should be defined' do
+						expect(subject).to respond_to(:access_key_id=)
+						expect{ subject.access_key_id = 123 }.to change{ attributes[:access_key_id] }.from(nil).to(123)
+					end
+					it 'should have an alias writer defined' do
+						expect(subject).to respond_to(:access_key=)
+						expect{ subject.access_key = 123 }.to change{ attributes[:access_key_id] }.from(nil).to(123)
+					end
+				end
+			end
+
+			describe 'secret_access_key' do
+				context 'getter' do
+					subject { Credential.new(secret_key: 123) }
+					it 'should be defined' do
+						expect(subject).to respond_to(:secret_access_key)
+						expect(subject.secret_access_key).to eq 123
+					end
+					it 'should have an alias getter defined' do
+						expect(subject).to respond_to(:secret_key)
+						expect(subject.secret_key).to eq 123
+					end
+				end
+				context 'writer' do
+					let(:attributes) { subject.instance_variable_get(:@attributes) }
+					it 'should be defined' do
+						expect(subject).to respond_to(:secret_access_key=)
+						expect{ subject.secret_access_key = 123 }.to change{ attributes[:secret_access_key] }.from(nil).to(123)
+					end
+					it 'should have an alias writer defined' do
+						expect(subject).to respond_to(:secret_key=)
+						expect{ subject.secret_key = 123 }.to change{ attributes[:secret_access_key] }.from(nil).to(123)
+					end
+				end
+			end
+
+		end
+	end
+end

data/spec/cloud_sesame/domain/base_spec.rb

@@ -1,25 +1,290 @@
-require 'spec_helper'
-
 module CloudSesame
   module Domain
     describe Base do
 
-      let(:searchable_class) { "Test" }
-      subject { Base.new(searchable_class) }
+      class BaseSearchable; end
+
+      let(:searchable) { BaseSearchable }
+      subject { Base.new(searchable) }
 
-      describe '#initalize' do
-        it 'should set searchable class' do
-          expect(subject.searchable).to eq "Test"
+      shared_examples 'delegation to client' do |method|
+        it 'should be delegated to #client' do
+          expect(subject.client).to receive(method)
+          subject.send(method)
         end
       end
 
-      describe '#field' do
+      describe '#config' do
+        it_behaves_like 'delegation to client', :config
+      end
+
+      describe '#caching_with' do
+        it_behaves_like 'delegation to client', :caching_with
+      end
+
+      describe '#builder' do
+        it 'should initialize an new builder each time' do
+          number = 2
+          expect(Query::Builder).to receive(:new).exactly(number).times.and_call_original
+          number.times { subject.builder }
+        end
+        it 'should receive the context from base when called' do
+          c = Context.new
+          expect(subject).to receive(:context).and_return(c)
+          subject.builder
+        end
+        it 'should receive the searchable form base when called' do
+          expect(subject).to receive(:searchable).and_return(searchable)
+          subject.builder
+        end
       end
 
       describe '#client' do
+        it 'should initialize and return a domain client with searchable' do
+          expect(Client).to receive(:new).with(searchable)
+          subject.client
+        end
+      end
+
+      describe '#context' do
+        it 'should initialize and return a context' do
+          expect(Context).to receive(:new)
+          subject.context
+        end
+      end
+
+      describe '#default_size' do
+        it 'should store the value to context page size' do
+          size = 99
+          subject.default_size size
+          expect(subject.context[:page][:size]).to eq(size)
+        end
+        it 'should convert value to integer' do
+          size = "99"
+          subject.default_size size
+          expect(subject.context[:page][:size]).to eq(size.to_i)
+        end
+        it 'should add page size to context' do
+          expect{ subject.default_size 99 }.to change{ subject.context[:page] }.from(nil).to(hash_including(size: 99))
+        end
+      end
+
+      describe '#define_sloppiness' do
+        it 'should create a sloppiness node' do
+          value = 3
+          expect(Query::Node::Sloppiness).to receive(:new).with(value)
+          subject.define_sloppiness(value)
+        end
+        it 'should add query sloppiness to context' do
+          expect{ subject.define_sloppiness 3 }.to change{ subject.context[:query] }.from(nil).to(hash_including(sloppiness: Query::Node::Sloppiness))
+        end
+      end
+
+      describe '#define_fuzziness' do
+        let(:block) { Proc.new {} }
+        it 'should create a fuzziness node' do
+          expect(Query::Node::Fuzziness).to receive(:new) { |&b|
+            expect(b).to eq block
+          }
+          subject.define_fuzziness(&block)
+        end
+        it 'should add query fuzziness to context' do
+          expect{ subject.define_fuzziness {} }.to change{ subject.context[:query] }.from(nil).to(hash_including(fuzziness: Query::Node::Fuzziness))
+        end
+      end
+
+      describe '#field' do
+        let(:field_name) { :name }
+
+        shared_examples 'and options :as is also passed' do
+          let(:real_name) { :text1 }
+          before { options[:as] = real_name }
+          it 'should use the real name as field name' do
+            subject.field field_name, options
+            expect(custom_options).to include(real_name)
+          end
+        end
+
+        context 'when options :query is passed in' do
+          let(:options) { { query: true } }
+
+          context 'and query is set to true' do
+            it 'should add query options for field' do
+              subject.field(field_name, options)
+              expect(subject.context[:query_options][:fields][field_name]).to eq({})
+            end
+          end
+          context 'and query has options' do
+            it 'should use the query options for field' do
+              query_options = { weight: 2 }
+              options[:query] = query_options
+              subject.field(field_name, options)
+              expect(subject.context[:query_options][:fields][field_name]).to eq(query_options)
+            end
+          end
+
+          it_behaves_like 'and options :as is also passed' do
+            let(:options) { { query: true } }
+            let(:custom_options) { subject.context[:query_options][:fields] }
+          end
+        end
+
+        context 'when options :facet is passed in' do
+          let(:options) {{ facet: true }}
+          context 'and facet is set to true' do
+            it 'should add facet options for field' do
+              subject.field(field_name, options)
+              expect(subject.context[:facet][field_name]).to eq({})
+            end
+          end
+          context 'and facet has options' do
+            it 'should use the facet options defined' do
+              facet_options = { size: 2 }
+              options[:facet] = facet_options
+              subject.field(field_name, options)
+              expect(subject.context[:facet][field_name]).to eq(facet_options)
+            end
+          end
+
+          it_behaves_like 'and options :as is also passed' do
+            let(:options) { { facet: true } }
+            let(:custom_options) { subject.context[:facet] }
+          end
+        end
+
+        context 'when options :as is passed in' do
+          let(:options) {{ override: false }}
+          context 'and filter_query fields contains an options for field :as' do
+            let(:original_option) {{ hello: 'world', override: true }}
+            let(:real_name) { :text1 }
+            before {
+              options[:as] = real_name
+              ((subject.context[:filter_query] ||= {})[:fields] ||= {})[:text1] = original_option
+            }
+            it 'should delete the filter_query fields options for :as field' do
+              expect(subject.context[:filter_query][:fields]).to receive(:delete).with(real_name)
+              subject.field field_name, options
+            end
+            it 'should merge the original options into the new options' do
+              subject.field field_name, options
+              expect(subject.context[:filter_query][:fields][field_name]).to include({hello: 'world' })
+            end
+            it 'should not override the new options' do
+              subject.field field_name, options
+              expect(subject.context[:filter_query][:fields][field_name]).to include(override: false)
+            end
+          end
+        end
+
+        context 'when options :default is passed in' do
+          let(:proc) { Proc.new { } }
+          let(:options) {{ default: proc }}
+          it 'should remove the default lambda or proc from the options' do
+            expect(options).to receive(:delete).with(:default)
+            subject.field field_name, options
+          end
+          it 'should create a literal node using Query::Domain::Literal' do
+            domain = Query::Domain::Literal.new(field_name, {}, self)
+            expect(Query::Domain::Literal).to receive(:new).with(field_name, {}, self).and_return(domain)
+            expect(domain).to receive(:_eval) { |&block| expect(block).to eq proc }
+            subject.field field_name, options
+          end
+
+          context 'when default proc/lambda returns value' do
+            let(:proc) { Proc.new { "name" } }
+            it 'should store the literal node in filter query defaults of context' do
+              node = Query::Domain::Literal.new(field_name, {}, self)._eval(&proc)
+              allow_any_instance_of(Query::Domain::Literal).to receive(:_eval).and_return(node)
+              expect{ subject.field field_name, options }.to change{ subject.context[:filter_query] }.from(nil).to(hash_including(defaults: include(node)))
+            end
+          end
+
+          context 'when default proc/lambda returns nothing' do
+            it 'should not create any literal node in filter query defaults of context' do
+              node = Query::Domain::Literal.new(field_name, {}, self)._eval(&proc)
+              allow_any_instance_of(Query::Domain::Literal).to receive(:_eval).and_return(node)
+              expect{ subject.field field_name, options }.to_not change{ subject.send(:filter_query_defaults) }.from([])
+            end
+          end
+        end
+
+        it 'should create an field accessor' do
+          field_name = :an_indexed_field
+          expect{ subject.field field_name, {} }.to change{ Query::DSL::FieldAccessors.instance_methods }.by([field_name])
+        end
+
+        context 'when options is passed in' do
+          let(:options) {{ hello: "world" }}
+          it 'should store the options in filter query fields' do
+            subject.field field_name, options
+            expect(subject.context[:filter_query][:fields][field_name]).to eq options
+          end
+        end
+
+        context 'when no options is passed in' do
+          it 'should create a options in filter query fields' do
+            subject.field field_name
+            expect(subject.context[:filter_query][:fields][field_name]).to eq({})
+          end
+        end
       end
 
-      describe '#query' do
+      describe '#scope' do
+        let(:scope_name) { :test_scope }
+        context 'when no proc or block is given' do
+          it 'should not add anything to filter query scopes' do
+            expect{ subject.scope(scope_name) }.to_not change{ subject.send(:filter_query_scopes) }
+          end
+        end
+        context 'when proc is given' do
+          let(:proc) { Proc.new {} }
+          it 'should add the proc to the filter query scopes' do
+            expect{ subject.scope(scope_name, proc) }.to change{ subject.send(:filter_query_scopes) }.from({}).to(hash_including( scope_name => proc))
+          end
+        end
+        context 'when block is given' do
+          let(:block) { -> { "block" } }
+          it 'should add the block to the filter query scopes' do
+             expect{ subject.scope(scope_name, &block) }.to change{ subject.send(:filter_query_scopes) }.from({}).to(scope_name => eq(block))
+          end
+        end
+      end
+
+      context 'when method missing' do
+        let(:undefined_method) { :undefined_method }
+        let(:args) { [1,2,3] }
+        context 'and builder resposnds to the method' do
+          let(:builder) { subject.builder }
+          before { allow(subject).to receive(:builder).and_return(builder) }
+          it 'should check if builder responds to the method' do
+            expect(builder).to receive(:respond_to?).with(undefined_method)
+            subject.undefined_method rescue nil
+          end
+          it 'should call method on builder with parameters passed in' do
+            allow(builder).to receive(:respond_to?).and_return(true)
+            expect(builder).to receive(undefined_method).with(*args)
+            subject.undefined_method(*args)
+          end
+        end
+
+        context 'and builder not responds to the methods but searchable do' do
+          it 'should check if callee existing and responds to the method' do
+            expect(searchable).to receive(:respond_to?).with(undefined_method)
+            subject.undefined_method rescue nil
+          end
+          it 'should call method on searchable with parameters passed in' do
+            allow(searchable).to receive(:respond_to?).and_return(true)
+            expect(searchable).to receive(undefined_method).with(*args)
+            subject.undefined_method(*args)
+          end
+        end
+
+        context 'both builder and searchable do not respond to the method' do
+          it 'should raise NoMethodError on subject' do
+            expect{ subject.undefined_method }.to raise_error(NoMethodError)
+          end
+        end
+
       end
 
     end