CloudSesame 0.4.6 → 0.5.0

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

@@ -5,7 +5,7 @@ module CloudSesame
 
 				def included?(field, value = nil)
 					!!(
-						(field_options = dsl_context[:fields][field.to_sym]) &&
+						(field_options = _context[:fields][field.to_sym]) &&
 						(applied = field_options[:applied]) &&
 						(
 							(!value && applied.values.any?) ||
@@ -19,7 +19,7 @@ module CloudSesame
 
 				def excluded?(field, value = nil)
 					!!(
-						(field_options = dsl_context[:fields][field.to_sym]) &&
+						(field_options = _context[:fields][field.to_sym]) &&
 						(applied = field_options[:applied]) &&
 						(
 							(!value && !applied.values.all?) ||
@@ -33,7 +33,7 @@ module CloudSesame
 
 				def applied_filters
 					applied = {}
-					dsl_context[:fields].each do |field, options|
+					_context[:fields].each do |field, options|
 						if options && options[:applied] &&
 							!(values = options[:applied].select { |k, v| v }.keys).empty?
 							applied[field] = values

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

@@ -6,7 +6,7 @@ module CloudSesame
 				# NEAR: creates a single NEAR node
 				# =======================================
 				def near(value, options = {})
-					create_literal AST::Near, options, value
+					_build_operator AST::Near, options, value
 				end
 
 				alias_method :sloppy,     :near
@@ -14,7 +14,7 @@ module CloudSesame
 				# PREFIX: creates a single PREFIX node
 				# =======================================
 				def prefix(value, options = {})
-					create_literal AST::Prefix, options, value
+					_build_operator AST::Prefix, options, value
 				end
 
 				alias_method :start_with,	:prefix
@@ -23,28 +23,21 @@ module CloudSesame
 				# PHRASE: creates a single PHRASE node
 				# =======================================
 				def phrase(value, options = {})
-					create_literal AST::Phrase, options, value
+					_build_operator AST::Phrase, options, value
 				end
 
 				# TERM: creates a single TERM node
 				# =======================================
 				def term(value, options = {})
-					create_literal AST::Term, options, value
+					_build_operator AST::Term, options, value
 				end
 
 				private
 
-				def fields
-					dsl_context[:fields]
-				end
-
-				def create_literal(klass, options, value)
-					(node = klass.new dsl_context, options) << fieldless_literal(value)
-					return node
-				end
-
-				def fieldless_literal(value)
-					AST::Literal.new nil, value
+				def _build_operator(klass, options, value)
+					node = klass.new _context, options
+					node << AST::Literal.new(nil, value)
+					node
 				end
 
 			end

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

@@ -4,19 +4,19 @@ module CloudSesame
 			module RangeMethods
 
 				def gt(input)
-					AST::RangeValue.new.gt(input)
+					AST::RangeValue.new.gt input
 				end
 
 				def gte(input)
-					AST::RangeValue.new.gte(input)
+					AST::RangeValue.new.gte input
 				end
 
 				def lt(input)
-					AST::RangeValue.new.lt(input)
+					AST::RangeValue.new.lt input
 				end
 
 				def lte(input)
-					AST::RangeValue.new.lte(input)
+					AST::RangeValue.new.lte input
 				end
 
 			end

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

@@ -29,7 +29,7 @@ module CloudSesame
 				def search
 					compiled = request.compile
 					raise Error::MissingQuery.new("Query or FilterQuery can not be empty!") if !compiled[:query] || compiled[:query].empty?
-					@response = searchable.cloudsearch.client.search compiled
+					@response = @searchable.cloudsearch.client.search compiled
 				end
 
 			end

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

@@ -0,0 +1,28 @@
+module CloudSesame
+	module Query
+		module DSL
+			module ScopeAccessors
+
+				def scopes(name = nil, *args)
+					defined_scopes = _scope.context[:scopes]
+					return _return if name.nil?
+					if defined_scopes && (block = defined_scopes[name.to_sym])
+						instance_exec *args, &block
+						_return
+					else
+						raise Error::ScopeNotDefined
+					end
+				end
+
+				private
+
+				def method_missing(name, *args, &block)
+					scopes name, *args
+				rescue Error::ScopeNotDefined
+					super
+				end
+
+			end
+		end
+	end
+end

data/lib/cloud_sesame/query/error/scope_not_defined.rb

@@ -0,0 +1,8 @@
+module CloudSesame
+  module Query
+    module Error
+      class ScopeNotDefined < Exception
+      end
+    end
+  end
+end

data/lib/cloud_sesame/query/scope.rb

@@ -0,0 +1,21 @@
+module CloudSesame
+	module Query
+		class Scope
+
+			attr_reader :_scope, :_return
+
+			def initialize(_scope, _return)
+				@_scope, @_return = _scope, _return
+			end
+
+			def _context
+				_scope.context
+			end
+
+			def <<(object)
+				_scope << object
+			end
+
+		end
+	end
+end

data/lib/cloud_sesame.rb

@@ -14,14 +14,13 @@ require 'cloud_sesame/config/credential'
 require 'cloud_sesame/query/error/invalid_syntax'
 require 'cloud_sesame/query/error/missing_operator_symbol'
 require 'cloud_sesame/query/error/missing_query'
+require 'cloud_sesame/query/error/scope_not_defined'
 
 # Query DSL Methods
 # ===============================================
-require 'cloud_sesame/query/dsl/base'
 require 'cloud_sesame/query/dsl/block_methods'
-require 'cloud_sesame/query/dsl/block_chaining_methods'
 require 'cloud_sesame/query/dsl/field_array_methods'
-require 'cloud_sesame/query/dsl/field_methods'
+require 'cloud_sesame/query/dsl/field_accessors'
 require 'cloud_sesame/query/dsl/filter_query_methods'
 require 'cloud_sesame/query/dsl/operator_methods'
 require 'cloud_sesame/query/dsl/page_methods'
@@ -29,15 +28,20 @@ require 'cloud_sesame/query/dsl/query_methods'
 require 'cloud_sesame/query/dsl/range_methods'
 require 'cloud_sesame/query/dsl/response_methods'
 require 'cloud_sesame/query/dsl/return_methods'
-require 'cloud_sesame/query/dsl/scope_methods'
+require 'cloud_sesame/query/dsl/scope_accessors'
 require 'cloud_sesame/query/dsl/sort_methods'
 
+# Query Query Domain Objects
+# ===============================================
+require 'cloud_sesame/query/domain/block'
+require 'cloud_sesame/query/domain/chaining_block'
+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/block_chaining_relation'
 require 'cloud_sesame/query/ast/field_array'
 require 'cloud_sesame/query/ast/and'
 require 'cloud_sesame/query/ast/or'
@@ -71,6 +75,7 @@ require 'cloud_sesame/query/node/return'
 # Query Builder Interface
 # ===============================================
 require 'cloud_sesame/query/builder'
+require 'cloud_sesame/query/scope'
 
 # Domain Objects
 # ===============================================
@@ -95,13 +100,15 @@ module CloudSesame
 
     def define_cloudsearch(&block)
       if block_given?
-        Domain::Base::DEFINITIONS[self] = block
+        Domain::Base.definitions[self] = block
+        cloudsearch._caller = block.binding.eval "self"
         cloudsearch.instance_eval &block
+        cloudsearch._caller = nil
       end
     end
 
     def load_definition_from(klass)
-      if (definition = Domain::Base::DEFINITIONS[self])
+      if (definition = Domain::Base.definitions[self])
         cloudsearch.instance_eval &definition
       end
     end

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

@@ -53,7 +53,7 @@ module CloudSesame
         describe '#compile' do
           before {
             subject.child = OpenStruct.new compile: ""
-            allow(subject.child).to receive(:compile)
+            allow(subject.child).to receive(:compile).and_return(" ")
           }
           it 'should compile it\'s child and detailed set to false' do
             expect(subject.child).to receive(:compile).with(SingleExpressionOperator::DETAILED)

data/spec/cloud_sesame/query/dsl/block_methods_spec.rb

@@ -5,7 +5,9 @@ module CloudSesame
 		module DSL
 			describe BlockMethods do
 
-				# Setup Test Class
+				# Setup
+				# =================================================
+
 				class Product
 					include CloudSesame
 					define_cloudsearch {}
@@ -13,99 +15,81 @@ module CloudSesame
 
 				subject(:cloudsearch) { Product.cloudsearch.builder }
 
-				# AND
-				# =======================================================
-				describe '#and' do
+				# Block Style Clause
+				# =================================================
+				shared_examples 'block styled clause' do
+
+					let(:node) { klass1.new({}) }
+					let(:root) { subject.request.filter_query.root }
+
+					let(:empty_block) { Proc.new { } }
+					let(:nested_block) { Proc.new { send(method, empty_block) } }
+
+					let(:clause_call) { subject.send(clause1, &empty_block) }
 
-					it 'should create an AND node' do
-						expect(AST::And).to receive(:new).once
-						subject.and
+					it "should create an multi-expression node" do
+						expect(klass1).to receive(:new).once
+						subject.send(clause1)
 					end
 
 					context 'when given a block' do
+						before { allow(klass1).to receive(:new).and_return(node) }
 
-						context 'when called from cloudsearch' do
-							it 'should become a child of root node' do
-								node = nil
-								subject.and { node = self; }
-								expect(subject.request.filter_query.root.children).to include(node)
+						context 'when called from cloudsearch build' do
+							it 'should add to root\'s children' do
+								expect{ clause_call }.to change{ root.children.size }.by(1)
+								expect(root.children).to include(node)
 							end
-							it 'should return cloudsearch' do
-								expect(subject.and {}).to eq subject
-							end
-							it 'should use self as the dsl scope in the block' do
-								block = ->(scope, node) { expect(scope).to eq node }
-								subject.and { block.call(dsl_scope, self) }
+							it 'should return the build itself' do
+								expect(clause_call).to eq(subject)
 							end
 						end
-
-						context 'when called from inside a block' do
-							it 'should become a child of the dsl_scope' do
-								parent = nil
-								child = nil
-								subject.or { parent = self; child = and! {} }
-								expect(parent.children).to include(child)
+						context 'when called within a nested block' do
+							it 'should add to scope\'s children' do
+								subject.send(clause2) do
+									child = send(clause1, &empty_block)
+									expect(_scope.children).to include(child)
+								end
 							end
 							it 'should return the node it self' do
-								node = AST::And.new({})
-								return_node = nil
-								allow(AST::And).to receive(:new).and_return(node)
-								subject.or { return_node = and! {} }
-								expect(return_node).to eq node
+								subject.send(clause2) {
+									child = send(clause1, &empty_block)
+									expect(child).to eq(node)
+								}
 							end
 						end
-
 					end
 
 					context 'when not given a block' do
-						it 'should reutnr a block chaining relation object' do
-							expect(subject.and).to be_kind_of(AST::BlockChainingRelation)
+						it 'should return a chaining block domain object' do
+							expect(subject.send(clause1)).to be_kind_of(Domain::ChainingBlock)
 						end
-						it 'should not add a child to it\'s dsl scope' do
-							expect{ subject.and }.to_not change { subject.request.filter_query.root.children.size }
+						it 'should NOT add any children to the scope node' do
+							expect{ subject.send(clause1) }.to_not change{ root.children.size }
 						end
 					end
+				end
+
 
+				# AND
+				# =======================================================
+				describe '#and' do
+					it_behaves_like 'block styled clause' do
+						let(:klass1) { AST::And }
+						let(:klass2) { AST::Or }
+						let(:clause1) { :and! }
+						let(:clause2) { :or! }
+					end
 				end
 
 				# OR
 				# =======================================================
 				describe '#or' do
-
-					it 'should create an Or node' do
-						expect(AST::Or).to receive(:new).once
-						subject.or
-					end
-
-					context 'when called from cloudsearch' do
-						it 'should become a child of root node' do
-							node = nil
-							subject.or { node = self; }
-							expect(subject.request.filter_query.root.children).to include(node)
-						end
-						it 'should return cloudsearch' do
-							expect(subject.or {}).to eq subject
-						end
-						it 'should use self as the dsl scope in the block' do
-							block = ->(scope, node) { expect(scope).to eq node }
-							subject.and { block.call(dsl_scope, self) }
-						end
-					end
-
-					context 'when called from inside a block' do
-						it 'should become a child of the dsl_scope' do
-							parent = nil
-							child = nil
-							subject.and { parent = self; child = or! {} }
-							expect(parent.children).to include(child)
-						end
-						it 'should return the node it self' do
-							node = AST::Or.new({})
-							return_node = nil
-							allow(AST::Or).to receive(:new).and_return(node)
-							subject.and { return_node = or! {} }
-							expect(return_node).to eq node
-						end
+					it_behaves_like 'block styled clause' do
+						let(:klass1) { AST::Or }
+						let(:klass2) { AST::And }
+						let(:clause1) { :or! }
+						let(:clause2) { :and! }
 					end
 				end
 

data/spec/cloud_sesame/query/dsl/{field_methods_spec.rb → field_accessors_spec.rb}

@@ -3,7 +3,7 @@ require 'spec_helper'
 module CloudSesame
 	module Query
 		module DSL
-			describe FieldMethods do
+			describe FieldAccessors do
 
 				# Setup Test Class
 				class Product

data/spec/cloud_sesame_spec.rb

@@ -25,6 +25,10 @@
 # 	class Product
 # 		include CloudSesame
 
+# 		def self.greeting
+# 			"hello world!"
+# 		end
+
 # 		define_cloudsearch do
 # 			# Product CloudSesame Config
 # 			config.endpoint = ENV['AWS_ENDPOINT']
@@ -62,26 +66,31 @@
 # 	end
 
 
-# 	# n = 10_000
-#  #  q = nil
-# 	# result = RubyProf.profile do
-# 	#   n.times do
-# 			q = Product.cloudsearch.query("black   jacket").sort(price: :asc).page(1).size(1000).and {
+# 	@tags = [1, 2]
+# 	n = 10_000
+#   q = nil
+# 	result = RubyProf.profile do
+# 	  n.times do
+# 			q = Product.cloudsearch.query("black   jacket").sort(price: :asc).page(1).size(1000)
+# 				.price { gt 100 }
+# 				.and {
 # 					or! {
-# 					tags "1", "2"
+# 					tags *@tags
+# 					tags
+# 					tags nil
 # 					and! {
 # 						tags.not "3", "4"
 # 					}
 # 					and!.not {
 # 						tags.start_with "5", "6"
-# 						tags.not.start_with "7"
-# 						tags.not.near "8"
+# 						tags.not.start_with("7")
+# 						tags.not.near("8", distance: 7)
 # 						tags start_with("9"), near("10")
-# 						tags term "11"
-# 						tags phrase "12"
+# 						tags term("11", boost: 2)
+# 						tags.not phrase "12"
 # 					}
 # 					or!.not {
-# 						price 25..100
+# 						price(25..100)
 # 						price 100...200
 # 						price gte(200).lt(300)
 # 						price gte(300)
@@ -93,30 +102,34 @@
 # 					}
 # 				}
 # 			}
-# 	# 		q.applied_filters
+# 			q.applied_filters
 
-# 	#   end
-# 	# end
-# 	# printer = RubyProf::FlatPrinter.new(result)
-# 	# printer.print(STDOUT, {})
+# 	  end
+# 	end
+# 	printer = RubyProf::FlatPrinter.new(result)
+# 	printer.print(STDOUT, {})
 
 # 	binding.pry
 
-#   # class TestClass
-#   #   def initialize
+#   # class ProductController
+
+#   #   def load_user
 #   #     @name = "scott"
 #   #   end
+
 #   #   def greeting
 #   #     "hello world!"
 #   #   end
-#   #   def test_method
-#   #     local = :test
+
+#   #   def search
+#   #   	load_user
 #   #     q = Product.cloudsearch.and {
 #   #       binding.pry
 #   #     }
 #   #   end
+
 #   # end
 
-#   # test = TestClass.new
-#   # test.test_method
+#   # test = ProductController.new
+#   # test.search
 # end