CloudSesame 0.4.6 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cf32f340cf6841019d81977531954030a530ed3
-  data.tar.gz: d7988194d15066773475a1d31727eb5c9f792f0a
+  metadata.gz: e496630f0f95249813a64396a44c5afb138ac417
+  data.tar.gz: 8b1ea78470d4452d2328fc3f64b7966064028e3e
 SHA512:
-  metadata.gz: 7982d45b231fb2bc993ebabe4f80bd0cab1339e5bdd752ea09ba844e211461167308109a9f5125e13e6d3b8ab544507ee65e5be77976a0e610218ea7cb243933
-  data.tar.gz: c7b726fe0702ebe5ed7238dfab3e7799346e672feaec162893430c02495d6ec1c6e738e0ffbaf3827c1717cf6981023d94a6bbdb93aff67c4f8fccdb239aeaf0
+  metadata.gz: a9fda75e99cc51ab852b0b08603d661c6ae9b554af033c6dbd1ecace4768a9f3d2067ff5ad31d138be426095d4222b697d2436c6e998fb31879932d97c3b5f3a
+  data.tar.gz: 398c9345b3d76df8114c2d83077749ed8923f22f4a8f21112b58fed691ca3a8b58d1e430923481e08632434ac3711723a5ae1437ecf77e2630e52e5b1e6da34c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    CloudSesame (0.4.6)
+    CloudSesame (0.5.0)
       activesupport (~> 3.2)
       aws-sdk (~> 2)
 
@@ -82,3 +82,6 @@ DEPENDENCIES
   pry (~> 0)
   rspec (~> 3)
   ruby-prof
+
+BUNDLED WITH
+   1.11.2

data/cloud_sesame.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'CloudSesame'
-  s.version     = '0.4.6'
-  s.date        = '2016-01-20'
+  s.version     = '0.5.0'
+  s.date        = '2016-02-01'
   s.summary     = "AWS CloudSearch Query DSL"
   s.description = "AWS CloudSearch Query DSL"
   s.authors = ['Scott Chu', 'Emily Fan', 'Greg Ward', 'David McHoull',

data/lib/cloud_sesame/domain/base.rb

@@ -3,11 +3,14 @@ module CloudSesame
 		class Base
 			extend Forwardable
 
-			attr_reader :searchable, :result
-
 			def_delegator :client, :config
 
-			DEFINITIONS = {}
+			attr_accessor :_caller
+			attr_reader :searchable
+
+			def self.definitions
+				@definitions ||= {}
+			end
 
 			def initialize(searchable)
 				@searchable = searchable
@@ -27,29 +30,28 @@ module CloudSesame
 
 			# DEFAULT CONTEXT METHODS
 			# =========================================
+
 			def default_size(value)
 				(context[:page] ||= {})[:size] = value
 			end
 
-			def field(name, options = {})
-				field_name = (options[:as] || name)
-				add_query field_name, options.delete(:query)
-				add_facet field_name, options.delete(:facet)
-
-				add_field_expression name.to_sym, options
-			end
-
 			def define_sloppiness(value)
 				(context[:query] ||= {})[:sloppiness] = value.to_i
 			end
 
-			def define_fuzziness(proc = nil, &block)
-				block = proc unless block_given?
+			def define_fuzziness(&block)
 				(context[:query] ||= {})[:fuzziness] = Query::Node::Fuzziness.new(&block)
 			end
 
+			# TODO
 			def default_scope(proc, &block)
-				scope :default, proc, &block
+			end
+
+			def field(name, options = {})
+				field_name = (options[:as] || name)
+				add_query field_name, options.delete(:query)
+				add_facet field_name, options.delete(:facet)
+				add_field name.to_sym, options
 			end
 
 			def scope(name, proc = nil, &block)
@@ -59,48 +61,56 @@ module CloudSesame
 
 			private
 
-			def ensure_hash(options)
+			def to_hash(options)
 				options.is_a?(Hash) ? options : {}
 			end
 
 			def add_query(name, options)
-				((context[:query_options] ||= {})[:fields] ||= {})[name] = ensure_hash(options) if options
+				((context[:query_options] ||= {})[:fields] ||= {})[name] = to_hash(options) if options
 			end
 
 			def add_facet(name, options)
-				(context[:facet] ||= {})[name] = ensure_hash(options) if options
+				(context[:facet] ||= {})[name] = to_hash(options) if options
 			end
 
-			def add_field_expression(name, options)
-				overriding_field_expression name, options
-				create_default_field_expression name, options
-				create_field_expression_writer name, options
+			def add_field(name, options)
+				replace_existing_field name, options
+				create_default_literal name, options
+				create_field_accessor name
+				(context[:filter_query][:fields] ||= {})[name] = options
 			end
 
-			def overriding_field_expression(name, options)
+			def replace_existing_field(name, options)
 				fields = ((context[:filter_query] ||= {})[:fields] ||= {})
 				if (as = options[:as]) && (existing = fields.delete(as))
 					options.merge! existing
 				end
 			end
 
-			def create_default_field_expression(name, options)
+			def create_default_literal(name, options)
 				if (block = options.delete(:default))
-					(context[:filter_query][:default] ||= []) << block
+					caller = block.binding.eval "self"
+					node = Query::Domain::Literal.new(name, options, caller)._eval(&block)
+					filter_query_defaults << node
 				end
 			end
 
-			def create_field_expression_writer(name, options)
-				(context[:filter_query][:fields] ||= {})[name] = options
-				Query::DSL::FieldMethods.send(:define_method, name) do |*values|
-					literal name, *values
+			def filter_query_defaults
+				context[:filter_query][:defaults] ||= []
+			end
+
+			def create_field_accessor(name)
+				Query::DSL::FieldAccessors.send(:define_method, name) do |*values, &block|
+					literal name, *values, &block
 				end
 			end
 
 			def method_missing(name, *args, &block)
 				builder.send(name, *args, &block)
-			# rescue NoMethodError
-			# 	super
+			rescue NoMethodError => e
+				_caller.send(name, *args, &block) if _caller
+			rescue NoMethodError => e
+				super
 			end
 
 		end

data/lib/cloud_sesame/query/ast/field_array.rb

@@ -4,8 +4,8 @@ module CloudSesame
       class FieldArray < Array
         include DSL::FieldArrayMethods
 
-        attr_accessor :dsl_return
-        attr_reader :field, :dsl_scope, :dsl_context
+        attr_accessor :_scope, :_return
+        attr_reader :field
 
         def field=(field)
           parents.clear
@@ -16,9 +16,8 @@ module CloudSesame
           @parents ||= []
         end
 
-        def dsl_scope=(dsl_scope)
-          @dsl_context = dsl_scope.context
-          @dsl_scope = dsl_scope
+        def _context
+          _scope && _scope.context
         end
 
         def compile

data/lib/cloud_sesame/query/ast/literal.rb

@@ -9,18 +9,21 @@ module CloudSesame
         attr_accessor :field
         attr_reader :options, :value
 
-        def initialize(field, value, options = {}, &block)
-          @field = field
-          @value = Value.parse value if value
-          @value = Value.parse(ValueEvaluator.new.instance_exec &block) if block_given?
+        def initialize(field, value = nil, options = {})
+          @field, @options = field, options
+          self.value = value
+        end
 
-          @options = options
-          is_included
+        def value=(value)
+          if value
+            @value = Value.parse value
+            is_included
+          end
         end
 
         def is_for(field, options = {})
           @field = field
-          @options = options.merge @options
+          @options.merge! options
         end
 
         def is_included
@@ -36,7 +39,7 @@ module CloudSesame
         end
 
         def compile(detailed = false)
-          detailed ? detailed_format : standard_format
+          (detailed ? detailed_format : standard_format) if value
         end
 
         private
@@ -57,10 +60,6 @@ module CloudSesame
           "'#{ data.gsub(SINGLE_QUATE) { ESCAPE_QUATE } }'"
         end
 
-        class ValueEvaluator
-          include DSL::RangeMethods
-        end
-
       end
     end
   end

data/lib/cloud_sesame/query/ast/multi_expression_operator.rb

@@ -2,20 +2,15 @@ module CloudSesame
   module Query
     module AST
       class MultiExpressionOperator < Operator
-        include DSL::Base
-        include DSL::BlockMethods
-        include DSL::FieldMethods
-        include DSL::FilterQueryMethods
-        include DSL::OperatorMethods
-        include DSL::RangeMethods
-        include DSL::ScopeMethods
 
         def children
           @children ||= create_children
         end
 
         def compile
-          "(#{ symbol  }#{ boost } #{ children.compile })" unless children.empty?
+          if !children.empty? && (compiled = children.compile) && !compiled.empty?
+            "(#{ symbol  }#{ boost } #{ compiled })"
+          end
         end
 
         def <<(object)
@@ -30,7 +25,7 @@ module CloudSesame
 
         def create_children
           array = FieldArray.new
-          array.dsl_scope = dsl_scope
+          array._scope = self
           array
         end
 

data/lib/cloud_sesame/query/ast/near.rb

@@ -6,7 +6,9 @@ module CloudSesame
 				SYMBOL = :near
 
 				def compile(detailed = nil)
-          "(#{ symbol }#{ boost }#{ distance } #{ child.compile operator_detailed })" if child
+          if child && (compiled = child.compile operator_detailed) && !compiled.empty?
+            "(#{ symbol }#{ boost }#{ distance } #{ compiled })"
+          end
 				end
 
         def distance

data/lib/cloud_sesame/query/ast/not.rb

@@ -10,7 +10,9 @@ module CloudSesame
         end
 
         def compile
-          "(#{ symbol  }#{ boost } #{ child.compile })" if child
+          if child && (compiled = child.compile) && !compiled.empty?
+            "(#{ symbol  }#{ boost } #{ compiled })"
+          end
         end
 
       end

data/lib/cloud_sesame/query/ast/root.rb

@@ -16,7 +16,7 @@ module CloudSesame
 
         def create_children
           array = FieldArray.new(context[:defaults] || [])
-          array.dsl_scope = dsl_scope
+          array._scope = self
           array
         end
 

data/lib/cloud_sesame/query/ast/single_expression_operator.rb

@@ -2,8 +2,6 @@ module CloudSesame
   module Query
     module AST
       class SingleExpressionOperator < Operator
-        include DSL::Base
-        include DSL::BlockMethods
 
         DETAILED = false
 
@@ -22,7 +20,9 @@ module CloudSesame
         end
 
         def compile(detailed = nil)
-          "(#{ symbol  }#{ boost } #{ child.compile operator_detailed })" if child
+          if child && (compiled = child.compile operator_detailed) && !compiled.empty?
+            "(#{ symbol  }#{ boost } #{ compiled })"
+          end
         end
 
         def operator_detailed

data/lib/cloud_sesame/query/builder.rb

@@ -1,20 +1,17 @@
 module CloudSesame
 	module Query
 		class Builder
-			include DSL::Base
-			include DSL::PageMethods
 			include DSL::QueryMethods
-			include DSL::ReturnMethods
-			include DSL::SortMethods
-
-			# # Filter Query DSL
+			include DSL::ResponseMethods
 			include DSL::BlockMethods
-			include DSL::FieldMethods
+			include DSL::FieldAccessors
 			include DSL::FilterQueryMethods
-			include DSL::ScopeMethods
-			include DSL::ResponseMethods
+			include DSL::ScopeAccessors
+			include DSL::PageMethods
+			include DSL::SortMethods
+			include DSL::ReturnMethods
 
-			attr_reader :context, :searchable
+			attr_reader :context
 
 			def initialize(context, searchable)
 				@context = Context.new.duplicate context
@@ -35,11 +32,22 @@ module CloudSesame
 
 			private
 
-			def dsl_scope
+			def _block_domain(block)
+				if block
+					caller = block.binding.eval("self")
+					Domain::Block.new caller, _context
+				end
+			end
+
+			def _scope
 				request.filter_query.root
 			end
 
-			def dsl_return(node = nil)
+			def _context
+				_scope.context
+			end
+
+			def _return
 				self
 			end
 

data/lib/cloud_sesame/query/domain/block.rb

@@ -0,0 +1,65 @@
+module CloudSesame
+	module Query
+		module Domain
+			class Block
+				include DSL::BlockMethods
+				include DSL::FieldAccessors
+				include DSL::ScopeAccessors
+        include DSL::OperatorMethods
+        include DSL::RangeMethods
+				include DSL::FilterQueryMethods
+
+				attr_reader :_caller, :_context, :_scopes
+
+				def initialize(_caller, _context)
+					@_caller = _caller
+					@_context = _context
+					@_scopes = []
+
+					@_caller.instance_variables.each do |name|
+						value = @_caller.instance_variable_get name
+						instance_variable_set name, value
+					end
+
+				end
+
+				def _eval(node, _scope, _return = _scope, &block)
+					_scopes.push node
+
+					# must build the subtree before push (<<) to it's
+					# parents (_scope) in order for the parent properly
+					# propagate message down to all the children.
+					# ===============================================
+					instance_eval &block
+					_scope << node
+
+					_scopes.pop
+					_scope.is_a?(AST::Root) ? _return : node
+				end
+
+				def _scope
+					_scopes[-1]
+				end
+
+				def _return
+					_scope
+				end
+
+				def _block_domain(block)
+					self
+				end
+
+				private
+
+				# ACCESS CALLER'S METHODS
+				# =========================================
+				def method_missing(name, *args, &block)
+					_caller.send(name, *args, &block)
+				rescue NoMethodError
+					super
+				end
+
+			end
+		end
+	end
+end

data/lib/cloud_sesame/query/domain/chaining_block.rb

@@ -0,0 +1,44 @@
+module CloudSesame
+	module Query
+		module Domain
+			class ChainingBlock
+
+				attr_reader :_orphan_node, :_scope, :_return
+
+				def initialize(_orphan_node, _scope, _return, _block_domain)
+					@_orphan_node = _orphan_node
+					@_scope = _scope
+					@_return = _return
+					@_block_domain = _block_domain
+				end
+
+				# CLAUSE: NOT
+				# =========================================
+
+				def not(options = {}, &block)
+					raise missing_block unless block_given?
+
+					node = AST::Not.new _scope.context, options
+					_block_domain(block)._eval _orphan_node, node, &block
+					_scope << node
+
+					_return || node
+				end
+
+				private
+
+				def _block_domain(block)
+					@_block_domain ||= (
+						caller = block.binding.eval("self")
+						Domain::Block.new caller, _scope.context
+					)
+				end
+
+				def missing_block
+					Error::InvalidSyntax.new("#{ orphan_node.class::SYMBOL }.not requires a block")
+				end
+
+			end
+		end
+	end
+end

data/lib/cloud_sesame/query/domain/literal.rb

@@ -0,0 +1,39 @@
+module CloudSesame
+	module Query
+		module Domain
+			class Literal
+				include DSL::RangeMethods
+
+				attr_reader :_name, :_options, :_caller
+
+				def initialize(_name, _options, _caller)
+					@_name = _name
+					@_options = _options
+					@_caller = _caller
+
+					_caller.instance_variables.each do |name|
+						value = _caller.instance_variable_get name
+						instance_variable_set name, value
+					end
+				end
+
+				def _eval(&block)
+					if block_given? && (_value = instance_exec &block)
+						AST::Literal.new _name, _value, _options
+					end
+				end
+
+				private
+
+				# ACCESS CALLER'S METHODS
+				# =========================================
+				def method_missing(name, *args, &block)
+					_caller.send(name, *args, &block)
+				rescue NoMethodError
+					super
+				end
+
+			end
+		end
+	end
+end

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

@@ -3,12 +3,10 @@ module CloudSesame
 		module DSL
 			module BlockMethods
 
-				attr_accessor :orphan_node
-
 				# CLAUSE: AND
 				# =========================================
 				def and(options = {}, &block)
-					block_style_dsl AST::And, options, &block
+					_block_style_clause AST::And, options, &block
 				end
 
 				alias_method :all,  :and
@@ -17,7 +15,7 @@ module CloudSesame
 				# CLAUSE: OR
 				# =========================================
 				def or(options = {}, &block)
-					block_style_dsl AST::Or, options, &block
+					_block_style_clause AST::Or, options, &block
 				end
 
 				alias_method :any, :or
@@ -25,34 +23,15 @@ module CloudSesame
 
 				private
 
-				def block_style_dsl(klass, options, &block)
-					node = klass.new dsl_context, options
+				def _block_style_clause(klass, options, &block)
+					node = klass.new _context, options
 					if block_given?
-						extract_caller_from block if on_root_level?
-						node.instance_eval &block
-						dsl_scope << node
-						dsl_return node
+						_block_domain(block)._eval node, _scope, _return, &block
 					else
-						chaining_relation_for(node)
+						Domain::ChainingBlock.new node, _scope, (_return if _scope.is_a?(AST::Root)), _block_domain(nil)
 					end
 				end
 
-				def chaining_relation_for(node)
-					AST::BlockChainingRelation.new(dsl_scope, dsl_return, node)
-				end
-
-				def on_root_level?
-					dsl_scope.is_a?(AST::Root)
-				end
-
-				def extract_caller_from(block)
-					dsl_context[:caller] = block.binding.eval "self"
-				end
-
-				def method_missing(name, *args, &block)
-					dsl_caller ? dsl_caller.send(name, *args, &block) : super
-				end
-
 			end
 		end
 	end

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

@@ -0,0 +1,24 @@
+module CloudSesame
+	module Query
+		module DSL
+			module FieldAccessors
+
+				def literal(name, *values, &block)
+					name = name.to_sym
+
+					if block_given?
+						caller = block.binding.eval "self"
+						options = _scope.context[:fields][name]
+			  		node = Domain::Literal.new(name, options, caller)._eval(&block)
+			  		values << node
+			  	end
+
+			  	_scope.children.field = name
+			  	_scope.children._return = _return
+			  	_scope.children.insert values
+				end
+
+			end
+		end
+	end
+end

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

@@ -38,10 +38,10 @@ module CloudSesame
 
 				def insert(values = [])
 					values.each do |value|
-						dsl_scope << create_parents(build_literal(value))
+						_scope << create_parents(build_literal(value))
 					end
 					parents.clear unless values.empty?
-				  dsl_return != dsl_scope ? dsl_return : self
+				  _return != _scope ? _return : self
 				end
 
 				private
@@ -52,7 +52,7 @@ module CloudSesame
 
 				def create_parents(child)
 					parents.compact.each do |parent|
-						node = parent[:klass].new dsl_context, parent[:options]
+						node = parent[:klass].new _context, parent[:options]
 						node << child
 						child = node
 					end
@@ -61,17 +61,13 @@ module CloudSesame
 
 				def build_literal(value)
 					if value.kind_of?(AST::SingleExpressionOperator) || value.is_a?(AST::Literal)
-						value.is_for field, field_options
+						value.is_for field, _context[:fields][field]
 						value
 					else
-						AST::Literal.new field, value, field_options
+						AST::Literal.new field, value, _context[:fields][field]
 					end
 				end
 
-				def field_options
-					dsl_context[:fields][field]
-				end
-
 			end
 		end
 	end