CloudSesame 0.1.6 → 0.2.0

data/lib/cloud_sesame/query/dsl/{filter_query.rb → filter_query_methods.rb}

@@ -1,22 +1,17 @@
 module CloudSesame
 	module Query
 		module DSL
-			module FilterQuery
-				include And
-				include Literal
-				include Or
-				include Scope
-				include Value
+			module FilterQueryMethods
 
 				def included?(field, value = nil)
-					(field_options = method_scope.context[:fields][field]) && (
+					(field_options = dsl_context[:fields][field]) && (
 						(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]) && (
+					(field_options = dsl_context[:fields][field]) && (
 						(value && field_options_is(:excluded, field_options, value)) ||
 						(!value && field_options_not_empty_in(:excluded, field_options))
 					)
@@ -32,7 +27,6 @@ module CloudSesame
 					field_options[type] && !field_options[type].empty?
 				end
 
-
 			end
 		end
 	end

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

@@ -0,0 +1,53 @@
+module CloudSesame
+	module Query
+		module DSL
+			module OperatorMethods
+
+				# NEAR: creates a single NEAR node
+				# =======================================
+				def near(value, options = {})
+					create_literal AST::Near, options, value
+				end
+
+				alias_method :sloppy,     :near
+
+				# PREFIX: creates a single PREFIX node
+				# =======================================
+				def prefix(value, options = {})
+					create_literal AST::Prefix, options, value
+				end
+
+				alias_method :start_with,	:prefix
+				alias_method :begin_with, :prefix
+
+				# PHRASE: creates a single PHRASE node
+				# =======================================
+				def phrase(value, options = {})
+					create_literal AST::Phrase, options, value
+				end
+
+				# TERM: creates a single TERM node
+				# =======================================
+				def term(value, options = {})
+					create_literal AST::Term, options, value
+				end
+
+				private
+
+				def fields
+					dsl_context[:fields]
+				end
+
+				def create_literal(klass, options, value)
+					(operator = klass.new dsl_context, options) << literal(value)
+					return operator
+				end
+
+				def literal(value)
+					AST::Literal.new nil, value
+				end
+
+			end
+		end
+	end
+end

data/lib/cloud_sesame/query/dsl/{page.rb → page_methods.rb}

@@ -1,12 +1,13 @@
 module CloudSesame
 	module Query
 		module DSL
-			module Page
+			module PageMethods
 
 				# CLAUSE: PAGE and SIZE
 				# =========================================
 				def page(input = nil)
 					if input
+						request.page.start = nil
 						request.page.page = input.to_i
 						return self
 					else
@@ -14,6 +15,16 @@ module CloudSesame
 					end
 				end
 
+				def start(input = nil)
+					if input
+						request.page.page = nil
+						request.page.start = input.to_i
+						return self
+					else
+						request.page.start
+					end
+				end
+
 				def size(input)
 					if input
 						request.page.size = input.to_i

data/lib/cloud_sesame/query/dsl/{query.rb → query_methods.rb}

@@ -1,7 +1,7 @@
 module CloudSesame
 	module Query
 		module DSL
-			module Query
+			module QueryMethods
 
 				def query(input = nil)
 					if input

data/lib/cloud_sesame/query/dsl/{return.rb → return_methods.rb}

@@ -1,7 +1,7 @@
 module CloudSesame
   module Query
     module DSL
-      module Return
+      module ReturnMethods
 
         def all_fields
           request.return_field.value = :all_fields

data/lib/cloud_sesame/query/dsl/{scope.rb → scope_methods.rb}

@@ -1,10 +1,10 @@
 module CloudSesame
 	module Query
 		module DSL
-			module Scope
+			module ScopeMethods
 
 				def scopes
-				  method_context[:scopes]
+				  dsl_context[:scopes]
 				end
 
 				private
@@ -12,7 +12,7 @@ module CloudSesame
 				def method_missing(name, *args, &block)
 					if scopes && (callback = scopes[name])
 						self.instance_exec *args, &callback
-					  method_return
+					  dsl_return
 					else
 						super
 					end

data/lib/cloud_sesame/query/dsl/{sort.rb → sort_methods.rb}

@@ -1,7 +1,7 @@
 module CloudSesame
 	module Query
 		module DSL
-			module Sort
+			module SortMethods
 
 				def sort(input = nil)
 					if input.is_a? Hash

data/lib/cloud_sesame/query/dsl/{value.rb → value_methods.rb}

@@ -1,10 +1,7 @@
 module CloudSesame
 	module Query
 		module DSL
-			module Value
-
-				# VALUE DSL
-        # =======================================
+			module ValueMethods
 
 				# DATE
         # =======================================

data/lib/cloud_sesame/query/{ast/leaf.rb → error/invalid_syntax.rb}

@@ -1,7 +1,7 @@
 module CloudSesame
   module Query
-    module AST
-      class Leaf
+    module Error
+      class InvalidSyntax < Exception
       end
     end
   end

data/lib/cloud_sesame/query/fuzziness.rb

@@ -0,0 +1,54 @@
+module CloudSesame
+  module Query
+    class Fuzziness
+
+      def initialize(&block)
+
+        # default fuzziness
+        @max_fuzziness = 3
+        @min_char_size = 6
+        @fuzzy_percent = 0.17
+
+        instance_eval &block if block_given?
+      end
+
+      def max_fuzziness(int)
+        @max_fuzziness = int.to_i
+      end
+
+      def min_char_size(int)
+        @min_char_size = int.to_i
+      end
+
+      def fuzzy_percent(float)
+        @fuzzy_percent = float.to_f
+      end
+
+      def parse(string)
+        result = each_with(string) { |word| fuzziness word }
+        join_by_and result
+      end
+
+      private
+
+      def each_with(string, &block)
+        string.split(' ').map &block
+      end
+
+      def fuzziness(word)
+        if word.length >= @min_char_size
+          fuzziness = (word.length * @fuzzy_percent).round
+          fuzziness = [fuzziness, @max_fuzziness].min
+          "#{word}~#{fuzziness}"
+        else
+          word
+        end
+      end
+
+      def join_by_and(*args)
+        (args = args.flatten.compact).size > 1 ? "(#{ args.join('+') })" : args[0]
+      end
+
+    end
+  end
+end

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

@@ -3,18 +3,18 @@ module CloudSesame
 		module Node
 			class Page < Abstract
 
-				attr_writer :page, :size
+				attr_writer :page, :size, :start
 
-				def page
-					@page ||= (context[:page] || 1)
-				end
+        def page
+					@page ||= context[:page] || 1
+        end
 
 				def size
-					@size ||= (context[:size] || 10)
+					@size ||= context[:size] || 10
 				end
 
 				def start
-					(page - 1) * size
+					@start ||= (page - 1) * size
 				end
 
 				def compile

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

@@ -3,24 +3,28 @@ module CloudSesame
 		module Node
 			class Query < Abstract
 
-				def terms=(array)
-					@terms = array
+				attr_writer :query
+
+				def query
+					@query ||= context[:query]
 				end
 
-				def terms
-					@terms ||= (q = context[:query]) ? q.split(' ') : []
+				def compile
+					{ query: join_by_or(query, fuzziness, sloppiness) }
 				end
 
-				def query
-					terms.map!(&:strip).join(' ')
+				private
+
+				def fuzziness
+					context[:fuzziness] ? context[:fuzziness].parse(query) : nil
 				end
 
-				def query=(string = '')
-					@terms = string.split(' ')
+				def sloppiness
+					context[:sloppiness] && query.include?(' ') ? "\"#{ query }\"~#{ context[:sloppiness] }" : nil
 				end
 
-				def compile
-					{ query: query }
+				def join_by_or(*args)
+					(args = args.flatten.compact).size > 1 ? "(#{ args.join('|') })" : args[0]
 				end
 
 			end

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

@@ -13,7 +13,7 @@ module CloudSesame
 					sorting_attributes[attribute.to_sym]
 				end
 
-				def []=(attribute, order = nil)
+				def []=(attribute, order = :desc)
 					sorting_attributes[attribute.to_sym] = order.to_sym if order
 				end
 

data/lib/cloud_sesame.rb

@@ -10,30 +10,34 @@ require 'cloud_sesame/config/credential'
 
 # Custom Errors
 # ===============================================
+require 'cloud_sesame/query/error/invalid_syntax'
 require 'cloud_sesame/query/error/missing_operator_symbol'
 require 'cloud_sesame/query/error/missing_query'
 
 # Query DSL Methods
 # ===============================================
 require 'cloud_sesame/query/dsl/base'
-require 'cloud_sesame/query/dsl/query'
-require 'cloud_sesame/query/dsl/page'
-require 'cloud_sesame/query/dsl/sort'
-require 'cloud_sesame/query/dsl/and'
-require 'cloud_sesame/query/dsl/or'
-require 'cloud_sesame/query/dsl/literal'
-require 'cloud_sesame/query/dsl/value'
-require 'cloud_sesame/query/dsl/scope'
-require 'cloud_sesame/query/dsl/filter_query'
-require 'cloud_sesame/query/dsl/boost'
-require 'cloud_sesame/query/dsl/return'
+require 'cloud_sesame/query/dsl/query_methods'
+require 'cloud_sesame/query/dsl/page_methods'
+require 'cloud_sesame/query/dsl/sort_methods'
+require 'cloud_sesame/query/dsl/return_methods'
+
+require 'cloud_sesame/query/dsl/block_methods'
+require 'cloud_sesame/query/dsl/block_chaining_methods'
+require 'cloud_sesame/query/dsl/field_methods'
+require 'cloud_sesame/query/dsl/field_array_methods'
+require 'cloud_sesame/query/dsl/filter_query_methods'
+require 'cloud_sesame/query/dsl/operator_methods'
+require 'cloud_sesame/query/dsl/scope_methods'
+require 'cloud_sesame/query/dsl/value_methods'
 
 # Query Query Filter Query AST Tree
 # ===============================================
-require 'cloud_sesame/query/ast/multi_branch'
-require 'cloud_sesame/query/ast/single_branch'
+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'
 require 'cloud_sesame/query/ast/not'
@@ -41,13 +45,11 @@ require 'cloud_sesame/query/ast/near'
 require 'cloud_sesame/query/ast/phrase'
 require 'cloud_sesame/query/ast/prefix'
 require 'cloud_sesame/query/ast/term'
-require 'cloud_sesame/query/ast/compound_array'
-require 'cloud_sesame/query/ast/root'
-require 'cloud_sesame/query/ast/leaf'
 require 'cloud_sesame/query/ast/literal'
 require 'cloud_sesame/query/ast/value'
 require 'cloud_sesame/query/ast/date_value'
 require 'cloud_sesame/query/ast/range_value'
+require 'cloud_sesame/query/ast/root'
 
 # Query Request Nodes
 # ===============================================
@@ -66,6 +68,7 @@ require 'cloud_sesame/query/node/return'
 # Query Builder Interface
 # ===============================================
 require 'cloud_sesame/query/builder'
+require 'cloud_sesame/query/fuzziness'
 
 # Domain Objects
 # ===============================================

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

@@ -16,12 +16,12 @@ module CloudSesame
         end
 
         describe '#method_return' do
-          let(:result) { subject.send(:method_return) }
+          let(:result) { subject.send(:dsl_return) }
           include_examples 'return self instance'
         end
 
         describe '#method_scope' do
-          let(:result) { subject.send(:method_scope) }
+          let(:result) { subject.send(:dsl_scope) }
           include_examples 'return self instance'
         end
 

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

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module CloudSesame
+	module Query
+		module DSL
+			describe BlockChainingMethods do
+
+				# Setup Test Class
+				class Product
+					include CloudSesame
+					define_cloudsearch {}
+				end
+
+				subject(:cloudsearch) { Product.cloudsearch }
+
+				after { subject.clear_request }
+
+				# NOT
+				# =======================================
+				describe '#not' do
+					let(:node_class) { AST::Not }
+
+					context 'when not called after an operator' do
+						it 'should raise an error' do
+							expect{ subject.not }.to raise_error NoMethodError
+						end
+					end
+					context 'when called after an multi expression operator method call' do
+						context 'and not block is given' do
+							it 'should raise an error' do
+								expect{ subject.or.not }.to raise_error Error::InvalidSyntax
+							end
+						end
+						context 'and block is given' do
+							it 'should create a NOT node' do
+								expect(node_class).to receive(:new).and_call_original
+								subject.and.not {}
+							end
+							it 'should create a operator node with the block passed to not' do
+								proc = -> { }
+								expect_any_instance_of(AST::And).to receive(:evaluate) { |context, options, &block|
+									expect(block).to eq(proc)
+								}
+								subject.and.not &proc
+							end
+							it 'should have the operator node as child' do
+								subject.and.not {}
+								expect(subject.request.filter_query.root.children[0].child ).to be_kind_of(AST::And)
+							end
+							it 'should belong to the dsl scope' do
+								expect{ subject.and.not {} }.to change{ subject.request.filter_query.root.children[0] }.from(nil).to be_kind_of(node_class)
+							end
+							context 'from root' do
+								it 'should return the cloudsearch domain' do
+									expect(subject.and.not {}).to eq subject
+								end
+							end
+							context 'from inside of nested block' do
+								it 'should return the Not node itself' do
+									node = nil
+									subject.and { node = or!.not {} }
+									expect(node).to be_kind_of(node_class)
+								end
+							end
+						end
+					end
+
+				end
+
+			end
+		end
+	end
+end

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

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+module CloudSesame
+	module Query
+		module DSL
+			describe BlockMethods do
+
+				# Setup Test Class
+				class Product
+					include CloudSesame
+					define_cloudsearch {}
+				end
+
+				subject(:cloudsearch) { Product.cloudsearch }
+
+				after { subject.clear_request }
+
+				# AND
+				# =======================================================
+				describe '#and' do
+
+					it 'should create an AND node' do
+						expect(AST::And).to receive(:new).once
+						subject.and
+					end
+
+					context 'when given a block' do
+
+						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)
+							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) }
+							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)
+							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
+							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)
+						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 }
+						end
+					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
+					end
+				end
+
+			end
+		end
+	end
+end

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

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module CloudSesame
+	module Query
+		module DSL
+			describe FieldArrayMethods do
+
+				# Setup Test Class
+				class Product
+					include CloudSesame
+					define_cloudsearch {
+						field :name
+						field :tags
+					}
+				end
+
+				subject(:cloudsearch) { Product.cloudsearch }
+
+				after { subject.clear_request }
+
+				shared_examples_for 'single_expression_operator' do |operation, klass, operator_weight|
+
+					it "should save the class #{ klass } into parents at index #{ operator_weight }" do
+						array = nil
+						subject.and { array = tags.send(operation) }
+						expect(array.parents[operator_weight]).to include klass: klass
+					end
+
+					context 'when given values' do
+						let(:array) {
+							array = nil
+							subject.and { array = tags.send(operation, "men") }
+							array
+						}
+
+						it 'should create a literal node with the value' do
+							expect(AST::Literal).to receive(:new).with(:tags, "men", Hash).and_call_original
+							array
+						end
+						it 'should create a near node' do
+							expect(klass).to receive(:new).and_call_original
+							array
+						end
+						it 'should set the literal node to near node child' do
+							expect(array.first.child).to be_kind_of(AST::Literal)
+							expect(array.first.child.value).to eq "men"
+						end
+						it 'should insert the near node to itself' do
+							expect(array).to include(klass)
+						end
+					end
+				end
+
+				describe '#near' do
+					it_should_behave_like "single_expression_operator", :near, AST::Near, 0
+				end
+
+				describe '#prefix' do
+					it_should_behave_like "single_expression_operator", :prefix, AST::Prefix, 0
+				end
+
+				describe '#not' do
+					it_should_behave_like "single_expression_operator", :not, AST::Not, 1
+				end
+
+			end
+		end
+	end
+end