CloudSesame 0.1.0

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

@@ -0,0 +1,71 @@
+module CloudSesame
+	module Query
+		module Node
+			class Request < Abstract
+
+				# CHILDREN
+				# =========================================
+
+				def query
+					@query ||= Query.new(context[:query, true])
+				end
+
+				def query_options
+					@query_options ||= QueryOptions.new(context[:query_options, true])
+				end
+
+				def query_parser
+					@query_parser ||= QueryParser.new(context[:query_parser, true])
+				end
+
+				def filter_query
+					@filter_query ||= FilterQuery.new(context[:filter_query, true])
+				end
+
+				def facet
+					@facet ||= Facet.new(context[:facet, true])
+				end
+
+				def page
+					@page ||= Page.new(context[:page, true])
+				end
+
+				def sort
+					@sort ||= Sort.new(context[:sort, true])
+				end
+
+				# EVALUATION
+				# =========================================
+
+				def compile
+					compiled = [
+						query,
+						query_options,
+						query_parser,
+						filter_query,
+						page,
+						sort
+					].each_with_object({}) do |node, compiled|
+						compiled.merge!(node.compile || {})
+					end
+
+					convert_to_structured_query(compiled) if compiled[:query].empty?
+
+					compiled
+				end
+
+				private
+
+				def convert_to_structured_query(compiled)
+					replace(compiled, :query, :filter_query).merge!(query_parser.structured.compile)
+				end
+
+				def replace(hash, key1, key2)
+					hash[key1] = hash.delete key2
+					hash
+				end
+
+			end
+		end
+	end
+end

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

@@ -0,0 +1,37 @@
+module CloudSesame
+	module Query
+		module Node
+			class Sort < Abstract
+
+				attr_reader :sorting_attributes
+
+				def sorting_attributes
+					@sorting_attributes ||= deserialize context[:sort]
+				end
+
+				def [](attribute)
+					sorting_attributes[attribute.to_sym]
+				end
+
+				def []=(attribute, order = nil)
+					sorting_attributes[attribute.to_sym] = order.to_sym if order
+				end
+
+				def compile
+					(result = serialize(sorting_attributes)).empty? ? {} : { sort: result }
+				end
+
+				private
+
+				def serialize(hash = {})
+					hash.to_a.map { |i| i.join(' ') }.join(',')
+				end
+
+				def deserialize(string)
+					Hash[*((string || "").split(',').map { |i| i.strip.split(' ').map(&:to_sym) }.flatten)]
+				end
+
+			end
+		end
+	end
+end

data/spec/abstract_object_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe AbstractObject do
+
+	# define TestConfig Class
+	class TestConfig < AbstractObject; end
+
+	describe '.accept' do
+		before { TestConfig.accept :access_key }
+
+		it 'should define attribute accessor using attribute name' do
+			expect(TestConfig.new).to respond_to(:access_key, :access_key=)
+		end
+
+		it 'should store attribute name in definitions' do
+			definitions = TestConfig.instance_variable_get(:@definitions)
+			expect(definitions).to include(access_key: :access_key)
+		end
+
+		context 'when accept attribute aliases' do
+			before { TestConfig.accept :access_key, as: [:access_key_id] }
+
+			it 'should define attribute accessor using default attribute name' do
+				expect(TestConfig.new).to respond_to(:access_key, :access_key=)
+			end
+			it 'should define attribute accessor using aliases' do
+				expect(TestConfig.new).to respond_to(:access_key_id, :access_key_id=)
+			end
+			it 'should store aliases in definitions' do
+				definitions = TestConfig.instance_variable_get(:@definitions)
+				expect(definitions).to include(access_key: :access_key, access_key_id: :access_key)
+			end
+		end
+
+		context 'when accept attribute with default value' do
+			let(:default_value) { SecureRandom.hex }
+			before { TestConfig.accept :access_key, default: default_value }
+
+			it 'should return default value if attribute hasn\'t being set' do
+				expect(TestConfig.new.access_key).to eq default_value
+			end
+		end
+
+	end
+
+	describe '#initialize' do
+
+		shared_examples 'acceptable attributes' do
+			it 'should set the acceptable attributes' do
+				expect(TestConfig.new(attributes_passed_in).to_hash).to include attributes_accepted
+			end
+		end
+
+		shared_examples 'unacceptable attributes' do
+			it 'should filter out the unacceptable attributes' do
+				expect(TestConfig.new(attributes_passed_in).to_hash).to_not include attributes_not_accepted
+			end
+		end
+
+		context 'when attributes passed is a hash' do
+			let(:attributes_accepted) { { access_key: 1 } }
+
+			context 'and attribute name is used' do
+				let(:attributes_passed_in) { { access_key: 1 } }
+				include_examples 'acceptable attributes'
+			end
+
+			context 'and attribute alias is used' do
+				let(:attributes_passed_in) { { access_key_id: 1 } }
+				include_examples 'acceptable attributes'
+			end
+
+			context 'and attribute is not in the definitions' do
+				let(:attributes_not_accepted) { { secret_key: 2 } }
+				let(:attributes_passed_in) { { secret_key: 2 } }
+				include_examples 'unacceptable attributes'
+			end
+
+
+		end
+		context 'when attributes passed is a config object' do
+			let(:attributes_accepted) { { access_key: 1 } }
+			let(:attributes_not_accepted) { { secret_key: 2 } }
+			let(:attributes_passed_in) { TestConfig.new(access_key: 1, secret_key: 2) }
+			include_examples 'acceptable attributes'
+			include_examples 'unacceptable attributes'
+		end
+	end
+
+	describe 'to_hash' do
+		let(:config) { TestConfig.new(access_key: 1) }
+
+		it 'should return config attributes in hash' do
+			expect(config.to_hash).to be_a(Hash)
+		end
+
+		it 'should not be able to manipulate the config through the hash' do
+			config.to_hash[:secret_key] = 2
+			expect(config.to_hash).to_not include(secret_key: 2)
+		end
+	end
+
+end

data/spec/cloud_sesame/domain/base_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module CloudSesame
+  module Domain
+    describe Base do
+
+      let(:searchable_class) { "Test" }
+      subject { Base.new(searchable_class) }
+
+      describe '#initalize' do
+        it 'should set searchable class' do
+          expect(subject.searchable_class).to eq "Test"
+        end
+      end
+
+      describe '#field' do
+      end
+
+      describe '#client' do
+      end
+
+      describe '#query' do
+      end
+
+    end
+  end
+end

data/spec/cloud_sesame/domain/context_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+module CloudSesame
+  module Domain
+    describe Context do
+
+      describe '#initialize' do
+        it 'should set default value to nil' do
+          expect(subject.table).to eq({})
+        end
+        it 'should accept an default value' do
+          context = Context.new(:default_value)
+          expect(context.table).to eq(:default_value)
+        end
+      end
+
+      describe '#[]' do
+        # it 'should return an '
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+module CloudSesame
+  module Query
+    module AST
+      describe And do
+        it 'should set the symbol to :and' do
+          expect(And.symbol).to eq :and
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+module CloudSesame
+  module Query
+    module AST
+      describe Literal do
+        let(:literal) { Literal.new('description', 'Shoes') }
+        let(:value) { Value.new("Shoes") }
+
+        # before { allow(Value).to receive(:new).and_return(value) }
+
+        describe '#initialize' do
+          it 'should store field' do
+            expect(literal.field).to eq('description')
+          end
+          it 'should create value node and store it' do
+            expect(Value).to receive(:new).with('Shoes').and_return(value)
+            expect(literal.value).to be_kind_of Value
+          end
+        end
+
+        describe '#compile' do
+          context 'when options is empty' do
+            it 'should compile value' do
+              expect_any_instance_of(Value).to receive(:compile).and_return("'Shoes'")
+              literal.compile
+            end
+            it 'should join the field and compiled value with colon' do
+              expect(literal.compile).to eq("description:'Shoes'")
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+module CloudSesame
+  module Query
+    module AST
+      describe MultiBranch do
+        let(:context) { {} }
+        let(:proc) { Proc.new { } }
+        let(:node) { MultiBranch.new(context, &proc) }
+
+        describe '#initialize' do
+          it 'should store the context' do
+            expect(node.context).to eq context
+          end
+          it 'should accepts an block and eval it' do
+            proc = Proc.new { test }
+            expect_any_instance_of(MultiBranch).to receive(:test)
+            MultiBranch.new(context, &proc)
+          end
+        end
+
+        describe '#children' do
+          it 'should instantiate an empty array' do
+            expect(CompoundArray).to receive(:new).and_call_original
+            node.children
+          end
+          it 'should return the array' do
+            node.children.concat([1,2,3])
+            expect(node.children).to eq [1,2,3]
+          end
+        end
+
+        describe '#compile_children' do
+          let(:children) {
+            [Value.new('value1'),
+              Value.new('value2')]
+          }
+          it 'should compile its children' do
+            children.each do |child|
+              expect(child).to receive(:compile)
+            end
+
+            node.children.concat(children)
+            node.compile_children
+          end
+
+          it 'should join its compiled children with a space' do
+            children.each do |child|
+              expect(child).to receive(:compile).and_call_original
+            end
+            node.children.concat(children)
+            expect(node.compile_children).to eq("'value1' 'value2'")
+          end
+        end
+
+        describe 'Query DSL' do
+          it 'should be included' do
+            expect(node).to respond_to(:and, :or, :literal)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+module CloudSesame
+  module Query
+    module AST
+      describe Operator do
+        let(:proc) { Proc.new {} }
+        let(:operator) { Operator.new({}, &proc )}
+        before { Operator.symbol = :symbol }
+
+        describe '#compile' do
+          it 'should raise an error if operator symbol has not being set' do
+            Operator.symbol = nil
+            expect{ operator.compile }.to raise_error(Error::MissingOperatorSymbol)
+          end
+
+          it 'should return nil if children are empty' do
+            expect(operator.compile).to eq(nil)
+          end
+
+          it 'should return a string with the symbol and compile children' do
+            operator.children.push Literal.new(:price, 10)
+            expect(operator.compile).to eq("(symbol price:10)")
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+module CloudSesame
+  module Query
+    module AST
+      describe Or do
+        it 'should set the symbol to :or' do
+          expect(Or.symbol).to eq :or
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+module CloudSesame
+  module Query
+    module AST
+      describe Root do
+
+        let(:root) { Root.new({}) }
+
+        describe '#compile' do
+          before { root.children.concat(children) }
+
+          context 'when it has multiple children' do
+            let(:children) {
+              [Literal.new(:tags, "flash_deal"),
+                Literal.new(:tags, "sales")]
+            }
+            it 'should inject an default operator' do
+              expect(root.compile).to eq "(and tags:'flash_deal' tags:'sales')"
+            end
+          end
+          context 'when it has 1 child' do
+            let(:children) {
+              [Literal.new(:tags, "flash_deal")]
+            }
+            it 'should compile the child' do
+              expect(root).to receive(:compile_children)
+              root.compile
+            end
+          end
+          context 'when it has no children' do
+            let(:children) { [] }
+            it 'should compile the child' do
+              expect(root).to receive(:compile_children)
+              root.compile
+            end
+          end
+        end
+
+      end
+    end
+  end
+end