CloudSesame 0.6.7 → 0.6.8

data/lib/cloud_sesame/domain/base.rb

@@ -5,7 +5,6 @@ module CloudSesame
 
 			def_delegators :client, :config, :caching_with
 
-			attr_accessor :_caller
 			attr_reader :searchable
 
 			def self.definitions

data/lib/cloud_sesame/domain/client_module/caching/rails_cache.rb

@@ -1,3 +1,5 @@
+require 'ostruct'
+
 module CloudSesame
 	module Domain
 		module ClientModule

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

@@ -11,10 +11,15 @@ module CloudSesame
 
 				def compile
 					if query && !query.empty?
-						compiled = ["(#{ query })"]
-						compiled << fuzziness.compile(query) if fuzziness
-						compiled << sloppiness.compile(query) if sloppiness
-						{ query: compiled.compact.join('|') }
+						compiled = "(#{ query })"
+
+						[fuzziness, sloppiness].each do |parser|
+							if parser && (parsed = parser.compile(query))
+								compiled << "|" << parsed
+							end
+						end
+
+						{ query: compiled }
 					end
 				end
 

data/spec/cloud_sesame/domain/client_module/caching_spec.rb

@@ -49,19 +49,25 @@ module CloudSesame
 				end
 
 				describe 'executor getter' do
+					it 'should return an Caching::NoCache executor by default' do
+						expect(subject.executor).to be_kind_of(Caching::NoCache)
+					end
 					it 'should default to Caching::NoCache' do
 						expect(Caching::NoCache).to receive(:new).with(subject.searchable) do |_, &lazy_client|
-							expect(lazy_client.call).to eq subject.client
-						end.and_call_original
-						expect(subject.executor).to be_kind_of Caching::NoCache
+							expect(lazy_client.call).to eq subject.aws_client
+						end
+						subject.executor
 					end
 				end
 
 				describe 'executor setter' do
 					it 'should accept a caching module' do
 						expect(Caching::GoodCache).to receive(:new).with(subject.searchable) do |_, &lazy_client|
-							expect(lazy_client.call).to eq subject.client
-						end.and_call_original
+							expect(lazy_client.call).to eq subject.aws_client
+						end
+						subject.executor = Caching::GoodCache
+					end
+					it 'should return a Caching::GoodCache instance' do
 						subject.executor = Caching::GoodCache
 						expect(subject.executor).to be_kind_of Caching::GoodCache
 					end

data/spec/cloud_sesame/query/ast/single_expression_operator_spec.rb

@@ -35,12 +35,6 @@ module CloudSesame
               subject.is_excluded
             end
           end
-          context 'when child not exist' do
-            it 'should call #is_excluded on it\'s child' do
-              expect(subject.child).to_not receive(:is_excluded)
-              subject.is_excluded
-            end
-          end
         end
 
         describe '#<<' do

data/spec/cloud_sesame/query/node/query_spec.rb

@@ -4,56 +4,100 @@ module CloudSesame
   module Query
     module Node
       describe Query do
-        let(:arguments) {{ }}
-        let(:node) { Query.new(arguments) }
+        let(:context) {{ }}
+        let(:node) { Query.new(context) }
+        subject { Query.new(context) }
 
-        describe '#initialize' do
-          context 'when arguments passed in' do
-            let(:arguments) {{ query: "" }}
-            it 'should initalize an empty string if query is empty' do
-              expect(node.query).to eq ""
-            end
-            it 'should accept query as args and initialize query' do
-              arguments[:query] = "hello world"
-              expect(node.query).to eq "hello world"
+        describe '#query' do
+          context 'when context include query on initialize' do
+            let(:query_string) { "hello world" }
+            let(:context) { { query: query_string }}
+            it 'should set query to context query' do
+              expect(subject.query).to eq query_string
             end
           end
-          context 'when arguments not passed in' do
-            it 'should initialize an empty terms' do
-              expect(node.query).to eq nil
+          context 'when context does not include query on initialize' do
+            it 'should just return nil' do
+              expect(subject.query).to eq nil
             end
           end
         end
 
-        describe '#query' do
-          it 'should return the query string' do
-            node.query = ["term1", "term2", "term3", "-term4"].join(' ')
-            expect(node.query).to eq "term1 term2 term3 -term4"
-          end
-        end
-
         describe '#compile' do
-          context 'when fuzziness is defined' do
-            it 'should parse with fuzziness' do
-              fuzziness = Fuzziness.new
-              node = Query.new(fuzziness: fuzziness)
-              node.query = ["term1", "someterm2", "verylongterm3", "-excluded_term4"].join(' ')
-              expect(fuzziness).to receive(:compile).with(node.query).and_call_original
-              expect(node.compile).to eq(query: "(term1 someterm2 verylongterm3 -excluded_term4)|(term1+someterm2~2+verylongterm3~2+-excluded_term4)")
+
+          shared_examples 'common query compile actions' do
+            context 'and query is nil' do
+              let(:query_string) { nil }
+              it 'should return nil' do
+                expect(subject.compile).to eq nil
+              end
+            end
+            context 'and query is empty' do
+              let(:query_string) { "" }
+              it 'should return nil' do
+                expect(subject.compile).to eq nil
+              end
+            end
+            context 'and query contains one word' do
+              let(:query_string) { "oneword" }
+              it 'should include the original string inside parenthesis' do
+                expect(subject.compile[:query]).to include("(#{ query_string })")
+              end
+            end
+            context 'and query contains multiple words' do
+              let(:query_string) { "one three fourty longword" }
+              it 'should include the original string inside parenthesis' do
+                expect(subject.compile[:query]).to include("(#{ query_string })")
+              end
             end
           end
-          context 'when sloppiness is defined' do
-            it 'should parse with sloppiness' do
-              sloppiness = Sloppiness.new(4)
-              node = Query.new(sloppiness: sloppiness)
-              node.query = ["term1", "term2", "term3", "-term4"].join(' ')
-              expect(sloppiness).to receive(:compile).with(node.query).and_call_original
-               expect(node.compile).to eq(query: "(term1 term2 term3 -term4)|\"term1 term2 term3 -term4\"~4")
+
+          shared_examples 'with additional parser defined' do |parser_name|
+            context 'and query string is nil' do
+              let(:query_string) { nil }
+              it "should not trigger #{ parser_name }" do
+                expect(parser).to_not receive(:compile)
+                subject.compile
+              end
+            end
+            context 'and query string is empty' do
+              let(:query_string) { "" }
+              it "should not trigger #{ parser_name }" do
+                expect(parser).to_not receive(:compile)
+                subject.compile
+              end
+            end
+            context 'and query string exist and not empty' do
+              let(:query_string) { "not empty" }
+              it "should trigger #{ parser_name }" do
+                result = parser.compile(query_string)
+                expect(parser).to receive(:compile).with(query_string).and_call_original
+                expect(subject.compile[:query]).to include(result)
+              end
             end
           end
-          it 'should return a serialized hash contains query string' do
-            node.query = ["term1", "term2", "term3", "-term4"].join(' ')
-            expect(node.compile).to eq({ query: "(term1 term2 term3 -term4)" })
+
+          context 'when both fuzziness and sloppiness are not defined' do
+            let(:context) {{ query: query_string }}
+            include_examples 'common query compile actions'
+          end
+          context 'when fuzziness is defined' do
+            let(:parser) { Fuzziness.new }
+            let(:context) {{
+              query: query_string,
+              fuzziness: parser
+            }}
+            include_examples 'common query compile actions'
+            include_examples 'with additional parser defined', "fuzziness"
+          end
+          context 'when sloppiness is defined' do
+            let(:parser) { Sloppiness.new(3) }
+            let(:context) {{
+              query: query_string,
+              sloppiness: parser
+            }}
+            include_examples 'common query compile actions'
+            include_examples 'with additional parser defined', "sloppiness"
           end
         end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: CloudSesame
 version: !ruby/object:Gem::Version
-  version: 0.6.7
+  version: 0.6.8
 platform: ruby
 authors:
 - Scott Chu