CloudSesame 0.6.8 → 0.7.0

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

@@ -2,77 +2,103 @@ module CloudSesame
 	module Query
 		module Node
 			class Request < Abstract
+				extend ClassSpecific
+
+				after_construct do |searchable|
+					@query = Query.construct_class(searchable)
+				end
+
+				def self.query
+					@query
+				end
 
 				# CHILDREN
 				# =========================================
 
 				def query
-					@query ||= Query.new(context[:query] ||= {})
+					@query ||= self.class.query.new(context[:query])
 				end
 
 				def query_options
-					@query_options ||= QueryOptions.new(context[:query_options] ||= {})
+					@query_options ||= QueryOptions.new(context[:query_options])
 				end
 
 				def query_parser
-					@query_parser ||= QueryParser.new(context[:query_parser] ||= {})
+					@query_parser ||= QueryParser.new(context[:query_parser])
 				end
 
 				def filter_query
-					@filter_query ||= FilterQuery.new(context[:filter_query] ||= {})
+					@filter_query ||= FilterQuery.new(context[:filter_query])
 				end
 
 				def facet
-					@facet ||= Facet.new(context[:facet] ||= {})
+					@facet ||= Facet.new(context[:facet])
 				end
 
 				def page
-					@page ||= Page.new(context[:page] ||= {})
+					@page ||= Page.new(context[:page])
 				end
 
 				def sort
-					@sort ||= Sort.new(context[:sort] ||= {})
+					@sort ||= Sort.new(context[:sort])
 				end
 
 				def return_field
-					@return ||= Return.new(context[:return] ||= {})
+					@return ||= Return.new(context[:return])
 				end
 
 				# EVALUATION
 				# =========================================
 
 				def compile
-					compiled = [
-						query,
-						query_options,
-						query_parser,
-						filter_query,
-						facet,
-						page,
-						sort,
-						return_field
-					].each_with_object({}) do |node, object|
-						object.merge!(node.compile || {})
-					end
+					compiled = {}
+					insert_query compiled
+					insert_filter_query compiled
+					insert_query_parser compiled
+					insert_rest compiled
+					insert_page compiled
+					compiled
+				end
+
+				private
 
-					if compiled[:filter_query].empty?
-						compiled.delete(:filter_query)
-					elsif compiled[:query].nil? || compiled[:query].empty?
-						convert_to_structured_query(compiled)
+				def insert_query(compiled)
+					if (compiled_query = query.compile) && !compiled_query.empty?
+						compiled[:query] = compiled_query
 					end
+				end
 
-					compiled
+				def insert_filter_query(compiled)
+					if (compiled_fq = filter_query.compile)
+						if compiled[:query]
+							query_parser.simple
+							compiled[:filter_query] = compiled_fq
+						else
+							query_parser.structured
+							compiled[:query] = compiled_fq
+						end
+					end
 				end
 
-				private
+				def insert_query_parser(compiled)
+					compiled[:query_parser] = query_parser.compile
+				end
 
-				def convert_to_structured_query(compiled)
-					replace(compiled, :query, :filter_query).merge! query_parser.structured.compile
+				def insert_rest(compiled)
+					{
+						query_options: query_options,
+						facet: facet,
+						sort: sort,
+						return: return_field
+					}.each do |name, node|
+						compiled_node = node.compile
+						compiled[name] = compiled_node if compiled_node
+					end
+					compiled
 				end
 
-				def replace(hash, key1, key2)
-					hash[key1] = hash.delete key2
-					hash
+				def insert_page(compiled)
+					compiled.merge! page.compile
 				end
 
 			end

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

@@ -3,32 +3,46 @@ module CloudSesame
 		module Node
 			class Sort < Abstract
 
-				attr_writer :sorting_attributes
+				attr_writer :attributes
 
-				def sorting_attributes
-					@sorting_attributes ||= deserialize context[:sort]
+				def attributes
+					@attributes ||= {}
 				end
 
 				def [](attribute)
-					sorting_attributes[attribute.to_sym]
+					attributes[attribute.to_sym]
 				end
 
-				def []=(attribute, order = :desc)
-					sorting_attributes[attribute.to_sym] = order.to_sym if order
+				def []=(attribute, order)
+					attributes[attribute.to_sym] = order
 				end
 
 				def compile
-					(result = serialize(sorting_attributes)).empty? ? {} : { sort: result }
+					unless (compiled = serialize attributes).empty?
+						compiled
+					end
 				end
 
 				private
 
-				def serialize(hash = {})
-					hash.to_a.map { |i| i.join(' ') }.join(',')
+				def serialize(hash)
+					hash.each_with_object("") do |(k, v), o|
+						o << (o.empty? ? '' : ',') << serialize_field(k, v)
+					end
 				end
 
-				def deserialize(string)
-					Hash[*((string || "").split(',').map { |i| i.strip.split(' ').map(&:to_sym) }.flatten)]
+				def serialize_field(name, value)
+					"#{ field_name(name) } #{ value }"
+				end
+
+				def field_name(key)
+					(name = alias_field(key)) ? name : key
+				end
+
+				def alias_field(key)
+					context[:fields] &&
+					context[:fields][key] &&
+					context[:fields][key][:as]
 				end
 
 			end

data/lib/cloud_sesame.rb

@@ -1,13 +1,13 @@
 # External Libraries
 # ===============================================
-require 'active_support/core_ext/object/deep_dup'
 require 'aws-sdk'
 require 'forwardable'
 
 # Internal Libraries
 # ===============================================
-require 'abstract_object'
-require 'cloud_sesame/config/credential'
+require 'services/abstract_object'
+require 'services/class_specific'
+require 'services/lazy_object'
 
 # Custom Errors
 # ===============================================
@@ -16,6 +16,10 @@ require 'cloud_sesame/query/error/missing_operator_symbol'
 require 'cloud_sesame/query/error/missing_query'
 require 'cloud_sesame/query/error/scope_not_defined'
 
+# Global Credential
+# ===============================================
+require 'cloud_sesame/config/credential'
+
 # Query DSL Methods
 # ===============================================
 require 'cloud_sesame/query/dsl/applied_filter_query'
@@ -25,14 +29,12 @@ require 'cloud_sesame/query/dsl/field_accessors'
 require 'cloud_sesame/query/dsl/scope_accessors'
 require 'cloud_sesame/query/dsl/operators'
 require 'cloud_sesame/query/dsl/field_array_methods'
-
-require 'cloud_sesame/query/dsl/range_helper'
+require 'cloud_sesame/query/dsl/inspect_method'
 require 'cloud_sesame/query/dsl/page_methods'
 require 'cloud_sesame/query/dsl/query_methods'
-
+require 'cloud_sesame/query/dsl/range_helper'
 require 'cloud_sesame/query/dsl/response_methods'
 require 'cloud_sesame/query/dsl/return_methods'
-
 require 'cloud_sesame/query/dsl/sort_methods'
 
 # Query Query Domain Objects
@@ -43,9 +45,10 @@ require 'cloud_sesame/query/domain/literal'
 
 # Query Query Filter Query AST Tree
 # ===============================================
-require 'cloud_sesame/query/ast/operator'
-require 'cloud_sesame/query/ast/multi_expression_operator'
-require 'cloud_sesame/query/ast/single_expression_operator'
+require 'cloud_sesame/query/ast/abstract/operator'
+require 'cloud_sesame/query/ast/abstract/multi_expression_operator'
+require 'cloud_sesame/query/ast/abstract/single_expression_operator'
+require 'cloud_sesame/query/ast/abstract/value'
 require 'cloud_sesame/query/ast/field_array'
 require 'cloud_sesame/query/ast/and'
 require 'cloud_sesame/query/ast/or'
@@ -55,10 +58,11 @@ require 'cloud_sesame/query/ast/phrase'
 require 'cloud_sesame/query/ast/prefix'
 require 'cloud_sesame/query/ast/term'
 require 'cloud_sesame/query/ast/literal'
-require 'cloud_sesame/query/ast/value'
+require 'cloud_sesame/query/ast/string_value'
 require 'cloud_sesame/query/ast/date_value'
 require 'cloud_sesame/query/ast/numeric_value'
 require 'cloud_sesame/query/ast/range_value'
+require 'cloud_sesame/query/ast/value'
 require 'cloud_sesame/query/ast/root'
 
 # Query Request Nodes
@@ -80,7 +84,6 @@ require 'cloud_sesame/query/node/return'
 # Query Builder Interface
 # ===============================================
 require 'cloud_sesame/query/builder'
-require 'cloud_sesame/query/scope'
 
 # Domain Objects
 # ===============================================

data/lib/services/class_specific.rb

@@ -0,0 +1,44 @@
+module ClassSpecific
+
+  def construct_class(klass, callback_args: [])
+    __constructor__(klass, callback_args) { |name| __define_subclass__ name, self }
+  end
+
+  def construct_module(klass, callback_args: [])
+    __constructor__(klass, callback_args) { |name| __define_submodule__ name, self }
+  end
+
+  def after_construct(&block)
+    @__construct_callback__ = block
+  end
+
+  private
+
+  def __constructor__(klass, callback_args)
+    constant = !(name = __get_constant_name__(klass)) ? self :
+               constants(false).include?(name.to_sym) ? const_get(name) :
+               yield(name)
+
+    __invoke_callback__(constant, klass, *callback_args) if @__construct_callback__
+    constant
+  end
+
+  def __invoke_callback__(constant, klass, *args)
+    eval_method = constant.is_a?(Class) ? :class_exec : :module_exec
+    constant.send(eval_method, klass, *args, &@__construct_callback__)
+    @__construct_callback__ = nil
+  end
+
+  def __define_subclass__(name, parent)
+    parent.const_set(name, Class.new(parent))
+  end
+
+  def __define_submodule__(name, parent)
+    parent.const_set(name, parent.clone)
+  end
+
+  def __get_constant_name__(constant)
+    (name = constant.to_s) ? name.slice(/(?=\:\:)?\w+$/) : nil
+  end
+
+end

data/lib/services/lazy_object.rb

@@ -0,0 +1,19 @@
+class LazyObject < BasicObject
+
+	def initialize(&callable)
+		@callable = callable
+	end
+
+	def __target_object__
+		@__target_object__ ||= @callable.call
+	end
+
+  def ==(object)
+    __target_object__ == object
+  end
+
+	def method_missing(method_name, *args, &block)
+		__target_object__.send(method_name, *args, &block)
+	end
+
+end

data/spec/cloud_sesame/domain/base_spec.rb

@@ -177,18 +177,12 @@ module CloudSesame
         end
 
         context 'when options :default is passed in' do
-          let(:proc) { Proc.new { } }
+          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" } }
@@ -208,9 +202,30 @@ module CloudSesame
           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])
+        context 'when option type is given' do
+          let(:options) {{ type: type }}
+          context 'and type is valid' do
+            let(:type) { :string }
+            it 'should reaplce the type symbol with the corresponded class' do
+              subject.field field_name, options
+              expect(subject.context[:filter_query][:fields][field_name]).to include({type: CloudSesame::Query::AST::StringValue })
+            end
+          end
+          context 'and type is not valid' do
+            let(:type) { nil }
+            it 'should reaplce the type symbol with the default value class' do
+              subject.field field_name, options
+              expect(subject.context[:filter_query][:fields][field_name]).to include({type: CloudSesame::Query::AST::Value })
+            end
+          end
+        end
+
+        context 'when option type is not given' do
+          let(:options) {{}}
+          it 'should set the field type to the default value class' do
+            subject.field field_name, options
+            expect(subject.context[:filter_query][:fields][field_name]).to include({type: CloudSesame::Query::AST::Value })
+          end
         end
 
         context 'when options is passed in' do
@@ -224,7 +239,7 @@ module CloudSesame
         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({})
+            expect(subject.context[:filter_query][:fields][field_name]).to include({type: CloudSesame::Query::AST::Value})
           end
         end
       end

data/spec/cloud_sesame/domain/client_module/caching/base_spec.rb

@@ -6,7 +6,8 @@ module CloudSesame
 
 					class Searchable; end
 
-					subject { Base.new(Searchable) {} }
+					let(:client) { instance_double(Client) }
+					subject { Base.new(client, Searchable) }
 
 					describe 'fetch' do
 						it 'should raise an error by default' do

data/spec/cloud_sesame/domain/client_module/caching/no_cache_spec.rb

@@ -6,9 +6,8 @@ module CloudSesame
 
 					class Searchable; end
 
-					let(:client) { OpenStruct.new(search: nil) }
-
-					subject { NoCache.new(Searchable) { client } }
+					let(:client) { instance_double(Client) }
+					subject { NoCache.new(client, Searchable) }
 
 					describe 'fetch' do
 						let(:params) {{}}

data/spec/cloud_sesame/domain/client_module/caching/rails_cache_spec.rb

@@ -27,20 +27,20 @@ module CloudSesame
 
 					# HELPERS
 					# =====================================
-					def hashify(params)
-						subject.send(:hashify, params)
+					def hexdigest(params)
+						subject.send(:hexdigest, params)
 					end
 
 					# TESTS
 					# =====================================
 
-					let(:client) { OpenStruct.new(search: nil) }
-					subject { RailsCache.new(Searchable) { client } }
+					let(:client) { instance_double(Client) }
+					subject { RailsCache.new(client, Searchable) }
 
 					shared_examples 'cache stored' do
 						it 'should cache the result' do
 							expect{ subject.fetch(params) }.to change{ Rails.cache.table.keys.size }
-							expect(Rails.cache.table[hashify(params)]).to eq results
+							expect(Rails.cache.table[hexdigest(params)]).to eq results
 						end
 					end
 
@@ -54,7 +54,7 @@ module CloudSesame
 						end
 
 						it 'should use the hash key generated from params to fetch the cache from Rails' do
-							hash_key = hashify(params)
+							hash_key = hexdigest(params)
 							expect(Rails.cache).to receive(:fetch).with(hash_key)
 							subject.fetch(params)
 						end

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

@@ -3,67 +3,68 @@ module CloudSesame
 		module ClientModule
 			describe Caching do
 
-				# SETUP
-				# =======================================
-
-				class Caching::GoodCache < Caching::Base
+				class Caching::GoodCache  < Caching::Base
 					def fetch(params); end
 				end
 
-				class Caching::BadCache < Caching::Base
-				end
-
-				class TestClient
-					include Caching
-
-					def aws_client
-						nil
+				let(:custom_cache) do
+					Class.new(Caching::Base) do
+						def fetch(params); end
 					end
+				end
 
-					def searchable
-						nil
+				let(:test_client) do
+					Class.new do
+						include Caching
+						def aws_client; end
+						def searchable; end
 					end
 				end
 
-				# TESTS
-				# =======================================
+				subject { test_client.new }
+				let(:aws_client) { subject.aws_client }
+				let(:searchable) { subject.searchable }
 
-				subject { TestClient.new }
+				before { custom_cache }
 
 				describe '#caching_with' do
 					context 'when giving an existing caching module' do
-						context 'and caching_module respond to fetch' do
-							let(:caching_module) { Caching::GoodCache }
-							before {
-								subject.caching_with(:GoodCache) }
-							it 'should set executor to the caching module' do
-								expect(subject.send(:executor)).to be_kind_of caching_module
-							end
+						let(:caching_module) { Caching::GoodCache }
+						before { subject.caching_with(:GoodCache) }
+						it 'should set executor to the caching module' do
+							expect(subject.executor).to be_kind_of caching_module
 						end
 					end
 					context 'when giving a non-existing caching module' do
 						it 'should raise Unrecognized Caching Module' do
-							expect{ subject.caching_with(:RedisCache) }.to raise_error(Error::Caching, "Unrecognized Caching Module")
+							expect{ subject.caching_with(:UnknowCache) }.to raise_error(NameError)
+						end
+					end
+					context 'when give a class directly' do
+						let(:caching_module) { custom_cache }
+						before { subject.caching_with(caching_module) }
+						it 'should set executor as the caching module' do
+							expect(subject.executor).to be_kind_of caching_module
 						end
 					end
 				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.aws_client
+						expect(Caching::NoCache).to receive(:new).with(aws_client, searchable) do |client, _|
+							expect(client).to eq subject.aws_client
 						end
 						subject.executor
 					end
+					it 'should return an Caching::NoCache executor by default' do
+						expect(subject.executor).to be_kind_of(Caching::NoCache)
+					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.aws_client
+						expect(Caching::GoodCache).to receive(:new).with(aws_client, searchable) do |client, _|
+							expect(client).to eq aws_client
 						end
 						subject.executor = Caching::GoodCache
 					end

data/spec/cloud_sesame/query/ast/abstract/multi_expression_operator_spec.rb

@@ -0,0 +1,67 @@
+module CloudSesame
+  module Query
+    module AST
+      module Abstract
+        describe MultiExpressionOperator do
+
+          let(:context) { {} }
+          let(:options) { {} }
+          let(:block) { Proc.new {} }
+
+          subject { MultiExpressionOperator.new(context, options, &block) }
+
+          it 'should be a type of operator' do
+            expect(MultiExpressionOperator.ancestors).to include(Operator)
+          end
+
+          describe '#children' do
+            it 'should be empty by default' do
+              expect(subject.children).to be_empty
+            end
+            it 'should be an Field Array' do
+              expect(subject.children).to be_a AST::FieldArray
+            end
+          end
+
+          describe '#compile' do
+            context 'when theres children' do
+              let(:child) { OpenStruct.new(compile: "compiled") }
+              before { subject.children << child }
+
+              it 'should compile to children' do
+                expect(subject.children).to receive(:compile)
+                subject.compile
+              end
+
+              context 'and boost options is given' do
+                before { subject.options[:boost] = 2 }
+                it 'should return compiled string with boost' do
+                  expect(subject.compile).to eq "( boost=2 compiled)"
+                end
+              end
+              context 'and boost options is not given' do
+                it 'should return compiled string with boost' do
+                  expect(subject.compile).to eq "( compiled)"
+                end
+              end
+            end
+            context 'when theres no children' do
+              it 'should return nothing' do
+                expect(subject.compile).to eq nil
+              end
+            end
+          end
+
+          describe '#<<' do
+            it 'should push object into the children' do
+              object = :hello
+              expect(subject.children).to receive(:<<).with(object)
+              subject << object
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/cloud_sesame/query/ast/abstract/operator_spec.rb

@@ -0,0 +1,29 @@
+module CloudSesame
+  module Query
+    module AST
+      module Abstract
+        describe Operator do
+          let(:context) {{}}
+          let(:options) {{}}
+          let(:block) { Proc.new {} }
+          subject { Operator.new(context, options, &block) }
+
+          describe '#boost' do
+            context 'given boost option' do
+              let(:options) { { boost: 2 } }
+              it 'should return an compiled boost value' do
+                expect(subject.boost).to eq " boost=2"
+              end
+            end
+            context 'given no boost option' do
+              it 'should return nothing' do
+                expect(subject.boost).to eq nil
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end