CloudSesame 0.1.5 → 0.1.6

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

@@ -1,21 +1,11 @@
 module CloudSesame
   module Query
     module AST
-      class Root < MultiBranch
+      class Root < And
+        self.symbol = :and
 
         def compile
-          if children.size > 1
-            join_by_default_operator.compile
-          else
-            compile_children
-          end
-        end
-
-        private
-
-        def join_by_default_operator
-          (default = And.new context).children.concat children
-          default
+          children.size > 1 ? super : compile_children
         end
 
       end

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

@@ -2,7 +2,6 @@ module CloudSesame
   module Query
     module AST
       class SingleBranch
-
         attr_accessor :child
       	attr_reader :context
 
@@ -13,11 +12,15 @@ module CloudSesame
 
         def child=(object)
           if object.kind_of? Literal
-            (object.options[:excluded] ||= []) << object.options[:included].delete(object.value.data)
+            (object.options[:excluded] ||= []) << object.options[:included].delete(object.value)
           end
           @child = object
         end
 
+        def <<(object)
+          self.child= object
+        end
+
       end
     end
   end

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

@@ -2,20 +2,18 @@ module CloudSesame
   module Query
     module AST
       class SingleExpressionOperator < SingleBranch
+        include DSL::Boost
 
-        # Operator Symbol Writer
         def self.symbol=(symbol)
           @symbol = symbol
         end
 
-        # Operator Symbol Getter
         def self.symbol
           @symbol
         end
 
         def compile
-          raise Error::MissingOperatorSymbol if self.class.symbol.nil?
-          "(#{ self.class.symbol  } #{ child.compile })" if child
+          "(#{ self.class.symbol  }#{ compile_boost } #{ child.compile })" if child
         end
 
       end

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

@@ -0,0 +1,14 @@
+module CloudSesame
+  module Query
+    module AST
+      class Term < SingleExpressionOperator
+        self.symbol = :term
+
+        def compile
+          child.detailed if child.kind_of?(Literal)
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -3,14 +3,22 @@ module CloudSesame
     module AST
       class Value < Leaf
 
-        attr_accessor :data
+        attr_reader :data
 
         def initialize(data)
           @data = data
         end
 
         def compile
-          format(data)
+          format data
+        end
+
+        def ==(value)
+          data == value || compile == value
+        end
+
+        def to_s
+          compile
         end
 
         private

data/lib/cloud_sesame/query/builder.rb

@@ -1,13 +1,14 @@
 module CloudSesame
 	module Query
-		class Builder
+		module Builder
 			include DSL::Base
 			include DSL::FilterQuery
 			include DSL::Page
 			include DSL::Query
 			include DSL::Sort
+			include DSL::Return
 
-			attr_reader :context, :searchable, :result
+			attr_reader :result
 
 			def initialize(default_context, searchable)
 				@context = default_context
@@ -18,26 +19,50 @@ module CloudSesame
 				@request ||= (clear_result; Node::Request.new context.dup)
 			end
 
+			def response
+				@response ||= search
+			end
+
 			def clear_request
 				@request = nil
 			end
 
 			def clear_result
-				@result = nil
+				@response = nil
+			end
+
+			def compile
+				request.compile
 			end
 
 			def inspect
-				"#<CloudSesame::Query::Builder:#{ object_id } #{ request.compile }>"
+				"#<#{ self.class }:#{ object_id } #{ compile }>"
 			end
 
 			# ENDING METHODS
 			# =========================================
 
+			def found
+				response.hits.found
+			end
+
+			def results
+				response.hits.hit
+			end
+
+			def each(&block)
+				results.each &block
+			end
+
+			def map(&block)
+				results.map &block
+			end
+
 			def search
 				compiled = request.compile
 				raise Error::MissingQuery.new("Query or FilterQuery can not be empty!") if !compiled[:query] || compiled[:query].empty?
 				clear_request
-				@result = searchable.cloudsearch.client.search compiled
+				@response = client.search compiled
 			end
 
 			private

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

@@ -0,0 +1,20 @@
+module CloudSesame
+	module Query
+		module DSL
+			module Boost
+
+				def compile_boost
+					" boost=#{ @boost }" if @boost
+				end
+
+				def boost(value)
+					@boost = value.to_i
+					return self
+				end
+
+				alias_method :weight, :boost
+
+			end
+		end
+	end
+end

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

@@ -2,43 +2,34 @@ module CloudSesame
 	module Query
 		module DSL
 			module FilterQuery
-				include Scope
 				include And
-				include Or
 				include Literal
-				include LiteralHelper
+				include Or
+				include Scope
+				include Value
 
-				# { fields: { tags: { excluded: [100] } } }
 				def included?(field, value = nil)
 					(field_options = method_scope.context[:fields][field]) && (
-						(value && field_includes?(field_options, value)) ||
-						(!value && field_included_is_not_empty?(field_options))
+						(value && field_options_is(:included, field_options, value)) ||
+						(!value && field_options_not_empty_in(:included, field_options))
 					)
 				end
 
 				def excluded?(field, value = nil)
 					(field_options = method_scope.context[:fields][field]) && (
-						(value && field_excludes?(field_options, value)) ||
-						(!value && field_excluded_is_not_empty?(field_options))
+						(value && field_options_is(:excluded, field_options, value)) ||
+						(!value && field_options_not_empty_in(:excluded, field_options))
 					)
 				end
 
 				private
 
-				def field_includes?(field_options, value)
-					field_options[:included] && field_options[:included].include?(value)
-				end
-
-				def field_included_is_not_empty?(field_options)
-					field_options[:included] && !field_options[:included].empty?
-				end
-
-				def field_excludes?(field_options, value)
-					field_options[:excluded] && field_options[:excluded].include?(value)
+				def field_options_is(type, field_options, value)
+					(values = field_options[type]) && values.include?(value)
 				end
 
-				def field_excluded_is_not_empty?(field_options)
-					field_options[:excluded] && !field_options[:excluded].empty?
+				def field_options_not_empty_in(type, field_options)
+					field_options[type] && !field_options[type].empty?
 				end
 
 

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

@@ -3,12 +3,45 @@ module CloudSesame
 		module DSL
 			module Literal
 
-				# CLAUSE: LITERAL
-				# =========================================
-				def literal(field, value, options = {})
-				  node = AST::Literal.new(field, value, options)
-				  method_scope.children << node
-				  node
+				# LITERAL: creates a single LITERAL node
+				# =======================================
+				def literal(value)
+					field = method_scope.children.field
+					AST::Literal.new field, value, fields[field]
+				end
+
+				alias_method :l,			    :literal
+				alias_method :field,  	  :literal
+
+				# NEAR: creates a single NEAR node
+				# =======================================
+				def near(value)
+					create_literal_with_operator AST::Near, value
+				end
+
+				alias_method :n,			    :near
+				alias_method :sloppy,     :near
+
+				# PREFIX: creates a single PREFIX node
+				# =======================================
+				def prefix(value)
+					create_literal_with_operator AST::Prefix, value
+				end
+
+				alias_method :p,					:prefix
+				alias_method :start_with,	:prefix
+				alias_method :begin_with, :prefix
+
+				# PHRASE: creates a single PHRASE node
+				# =======================================
+				def phrase(value)
+					create_literal_with_operator AST::Phrase, value
+				end
+
+				# TERM: creates a single TERM node
+				# =======================================
+				def term(value)
+					create_literal_with_operator AST::Term, value
 				end
 
 				private
@@ -17,10 +50,17 @@ module CloudSesame
 					method_context[:fields]
 				end
 
+				def create_literal_with_operator(klass, value)
+					field = method_scope.children.field
+					literal = AST::Literal.new field, value, fields[field]
+					(node = klass.new method_context) << literal
+					node
+				end
+
 				def method_missing(field, *values, &block)
 				  if fields && (options = fields[field])
-				  	method_scope.children.field = field
-				  	method_scope.children.insert_and_return_children(values)
+				  	method_scope.children.for_field field
+				  	method_scope.children.insert_and_return_children values
 				  else
 				    super
 				  end

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

@@ -3,6 +3,8 @@ module CloudSesame
 		module DSL
 			module Page
 
+				# CLAUSE: PAGE and SIZE
+				# =========================================
 				def page(input = nil)
 					if input
 						request.page.page = input.to_i
@@ -21,6 +23,8 @@ module CloudSesame
 					end
 				end
 
+				alias_method :limit,  :size
+
 			end
 		end
 	end

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

@@ -0,0 +1,21 @@
+module CloudSesame
+  module Query
+    module DSL
+      module Return
+
+        def all_fields
+          request.return_field.value = :all_fields
+        end
+
+        def no_fields
+          request.return_field.value = :no_fields
+        end
+
+        def score
+          request.return_field.value = :score
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module CloudSesame
+	module Query
+		module DSL
+			module Value
+
+				# VALUE DSL
+        # =======================================
+
+				# DATE
+        # =======================================
+				def date(date)
+					AST::DateValue.new date
+				end
+
+				alias_method :d, :date
+
+        # RANGE
+        # =======================================
+				def range(range = nil)
+					AST::RangeValue.new range
+				end
+
+				alias_method :r, :range
+
+			end
+		end
+	end
+end

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

@@ -34,6 +34,10 @@ module CloudSesame
 					@sort ||= Sort.new(context[:sort, true])
 				end
 
+				def return_field
+					@return ||= Return.new(context[:return, true])
+				end
+
 				# EVALUATION
 				# =========================================
 
@@ -44,7 +48,8 @@ module CloudSesame
 						query_parser,
 						filter_query,
 						page,
-						sort
+						sort,
+						return_field
 					].each_with_object({}) do |node, compiled|
 						compiled.merge!(node.compile || {})
 					end

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

@@ -0,0 +1,21 @@
+module CloudSesame
+  module Query
+    module Node
+      class Return < Abstract
+
+        attr_accessor :value
+
+        def compile
+          { return: format(value) } if value
+        end
+
+        private
+
+        def format(value)
+          value.to_s.gsub(/^_?/, '_')
+        end
+
+      end
+    end
+  end
+end