CloudSesame 0.6.4 → 0.6.5

data/lib/cloud_sesame.rb

@@ -67,6 +67,7 @@ require 'cloud_sesame/query/node/abstract'
 require 'cloud_sesame/query/node/request'
 require 'cloud_sesame/query/node/query'
 require 'cloud_sesame/query/node/fuzziness'
+require 'cloud_sesame/query/node/sloppiness'
 require 'cloud_sesame/query/node/query_options'
 require 'cloud_sesame/query/node/query_options_field'
 require 'cloud_sesame/query/node/query_parser'
@@ -106,15 +107,13 @@ module CloudSesame
     def define_cloudsearch(&block)
       if block_given?
         Domain::Base.definitions[self] = block
-        cloudsearch._caller = block.binding.eval "self"
-        cloudsearch.instance_eval &block
-        cloudsearch._caller = nil
+        cloudsearch.instance_eval(&block)
       end
     end
 
     def load_definition_from(klass)
-      if (definition = Domain::Base.definitions[self])
-        cloudsearch.instance_eval &definition
+      if (definition = Domain::Base.definitions[klass])
+        cloudsearch.instance_eval(&definition)
       end
     end
 

data/lib/cloud_sesame/domain/base.rb

@@ -32,31 +32,27 @@ module CloudSesame
 			# =========================================
 
 			def default_size(value)
-				(context[:page] ||= {})[:size] = value
+				page[:size] = value.to_i
 			end
 
 			def define_sloppiness(value)
-				(context[:query] ||= {})[:sloppiness] = value.to_i
+				query[:sloppiness] = Query::Node::Sloppiness.new(value)
 			end
 
 			def define_fuzziness(&block)
-				(context[:query] ||= {})[:fuzziness] = Query::Node::Fuzziness.new(&block)
-			end
-
-			# TODO
-			def default_scope(proc, &block)
+				query[:fuzziness] = Query::Node::Fuzziness.new(&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
+				add_query(field_name, options.delete(:query)) if options[:query]
+				add_facet(field_name, options.delete(:facet)) if options[:facet]
+				add_field(name.to_sym, options)
 			end
 
 			def scope(name, proc = nil, &block)
 				block = proc unless block_given?
-				((context[:filter_query] ||= {})[:scopes] ||= {})[name.to_sym] = block
+				filter_query_scopes[name.to_sym] = block if block
 			end
 
 			private
@@ -66,51 +62,68 @@ module CloudSesame
 			end
 
 			def add_query(name, options)
-				((context[:query_options] ||= {})[:fields] ||= {})[name] = to_hash(options) if options
+				((context[:query_options] ||= {})[:fields] ||= {})[name] = to_hash(options)
 			end
 
 			def add_facet(name, options)
-				(context[:facet] ||= {})[name] = to_hash(options) if options
+				(context[:facet] ||= {})[name] = to_hash(options)
 			end
 
 			def add_field(name, options)
-				replace_existing_field name, options
+				options = merge_with_as_field options if options[:as]
 				create_default_literal name, options
 				create_field_accessor name
-				(context[:filter_query][:fields] ||= {})[name] = options
+				filter_query_fields[name] = options
 			end
 
-			def replace_existing_field(name, options)
-				fields = ((context[:filter_query] ||= {})[:fields] ||= {})
-				if (as = options[:as]) && (existing = fields.delete(as))
-					options.merge! existing
-				end
+			def merge_with_as_field(options)
+				(existing = filter_query_fields.delete(options[:as])) ? existing.merge(options) : options
 			end
 
 			def create_default_literal(name, options)
 				if (block = options.delete(:default))
 					caller = block.binding.eval "self"
-					node = Query::Domain::Literal.new(name, options, caller)._eval(&block)
-					filter_query_defaults << node
+					domain = Query::Domain::Literal.new(name, options, caller)
+					node = domain._eval(&block)
+					filter_query_defaults << node if node
 				end
 			end
 
-			def filter_query_defaults
-				context[:filter_query][:defaults] ||= []
+			def create_field_accessor(name)
+				Query::DSL::FieldAccessors.__define_accessor__(name)
 			end
 
-			def create_field_accessor(name)
-				Query::DSL::FieldAccessors.send(:define_method, name) do |*values, &block|
-					literal name, *values, &block
+			def method_missing(name, *args, &block)
+				if builder.respond_to?(name)
+					builder.send(name, *args, &block)
+				elsif searchable.respond_to?(name)
+					searchable.send(name, *args, &block)
+				else
+					super
 				end
 			end
 
-			def method_missing(name, *args, &block)
-				builder.send(name, *args, &block)
-			rescue NoMethodError => e
-				_caller.send(name, *args, &block) if _caller
-			rescue NoMethodError => e
-				super
+			# CONTEXT ACCESSORS
+			# =========================================
+
+			def page
+				context[:page] ||= {}
+			end
+
+			def query
+				context[:query] ||= {}
+			end
+
+			def filter_query_fields
+				(context[:filter_query] ||= {})[:fields] ||= {}
+			end
+
+			def filter_query_defaults
+				(context[:filter_query] ||= {})[:defaults] ||= []
+			end
+
+			def filter_query_scopes
+				(context[:filter_query] ||= {})[:scopes] ||= {}
 			end
 
 		end

data/lib/cloud_sesame/domain/client_module/caching/base.rb

@@ -9,7 +9,7 @@ module CloudSesame
 						@searchable = searchable
 					end
 
-					def fetch(params)
+					def fetch(_params)
 						raise Error::Caching, "Caching Module needs #fetch method and accepts params"
 					end
 

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

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

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

@@ -6,7 +6,7 @@ module CloudSesame
 
         attr_reader :context, :options
 
-        def initialize(context, options = {}, &block)
+        def initialize(context, options = {})
           @context = context
           @options = options
         end

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

@@ -6,40 +6,41 @@ module CloudSesame
         RANGE_FORMAT = /\A(\[|{)(.*),(.*)(\}|\])\z/
 
         def initialize(value = nil)
-          @data = if value.kind_of?(Range)
-            range_to_array(value)
-          elsif value.is_a?(String) && (match = string_format?(value))
-            (matches = match.captures)[1, 2] = matches[1, 2].map do |i|
-              Value.parse(i) unless i.nil? || i.empty?
+          @data = (
+            if value.kind_of?(Range)
+              range_to_array(value)
+            elsif value.is_a?(String) && (match = string_format?(value))
+              data = match.captures
+              data[1, 2] = data[1, 2].map { |i| Value.parse(i) unless i.nil? || i.empty? }
+              data
+            else
+              default_range
             end
-            @data = matches
-          else
-            default_range
-          end
+          )
         end
 
         def gt(value = nil)
-          data[0], data[1] = '{', Value.parse(value) if value
+          update_lower_value(value) if value
           return self
         end
 
         def gte(value = nil)
-          data[0], data[1] = '[', Value.parse(value) if value
+          update_lower_value(value, true) if value
           return self
         end
 
         def lt(value = nil)
-          data[2], data[3] = Value.parse(value), '}' if value
+          update_uppoer_value(value) if value
           return self
         end
 
         def lte(value = nil)
-          data[2], data[3] = Value.parse(value), ']' if value
+          update_uppoer_value(value, true) if value
           return self
         end
 
         def compile
-          "#{ lb }#{ l.to_s },#{ u.to_s }#{ ub }"
+          "#{ data[0] }#{ data[1] },#{ data[2] }#{ data[3] }"
         end
 
         def ==(object)
@@ -48,6 +49,14 @@ module CloudSesame
 
         private
 
+        def update_lower_value(value, included = false)
+          data[0], data[1] = (included ? '[' : '{'), Value.parse(value)
+        end
+
+        def update_uppoer_value(value, included = false)
+          data[2], data[3] = Value.parse(value), (included ? ']' : '}')
+        end
+
         def string_format?(string)
            RANGE_FORMAT.match string.tr(' ', '')
         end
@@ -67,22 +76,6 @@ module CloudSesame
           ['{', nil, nil, '}']
         end
 
-        def l
-          data[1]
-        end
-
-        def u
-          data[2]
-        end
-
-        def lb
-          data[1] ? data[0] : '{'
-        end
-
-        def ub
-          data[2] ? data[3] : '}'
-        end
-
       end
     end
   end

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

@@ -19,7 +19,7 @@ module CloudSesame
           self.child = object
         end
 
-        def compile(detailed = nil)
+        def compile(_detailed = nil)
           if child && (compiled = child.compile operator_detailed) && !compiled.empty?
             "(#{ symbol  }#{ boost } #{ compiled })"
           end

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

@@ -12,10 +12,24 @@ module CloudSesame
 
         def self.parse(value)
           return value if value.kind_of? AST::Value
-          return AST::NumericValue.new(value) if value.is_a?(Numeric) || (value.is_a?(String) && DIGIT_FORMAT =~ value)
-          return AST::DateValue.new(value) if value.kind_of?(Date) || value.kind_of?(Time)
-          return AST::RangeValue.new(value) if value.kind_of?(Range) || (value.is_a?(String) && RANGE_FORMAT =~ value)
-          AST::Value.new(value)
+          (
+            is_a_numeric?(value) ? AST::NumericValue :
+            is_a_datetime?(value) ? AST::DateValue :
+            is_a_range?(value) ? AST::RangeValue :
+            AST::Value
+          ).new(value)
+        end
+
+        def self.is_a_numeric?(value)
+          value.is_a?(Numeric) || (value.is_a?(String) && DIGIT_FORMAT =~ value)
+        end
+
+        def self.is_a_datetime?(value)
+          value.kind_of?(Date) || value.kind_of?(Time)
+        end
+
+        def self.is_a_range?(value)
+          value.kind_of?(Range) || (value.is_a?(String) && RANGE_FORMAT =~ value)
         end
 
         def initialize(data)

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

@@ -27,7 +27,7 @@ module CloudSesame
 					# parents (_scope) in order for the parent properly
 					# propagate message down to all the children.
 					# ===============================================
-					instance_eval &block
+					instance_eval(&block)
 					_scope << node
 
 					_scopes.pop
@@ -42,7 +42,7 @@ module CloudSesame
 					_scope
 				end
 
-				def _block_domain(block)
+				def _block_domain(_block)
 					self
 				end
 

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

@@ -16,7 +16,7 @@ module CloudSesame
 				end
 
 				def _eval(&block)
-					if block_given? && (_value = instance_exec &block)
+					if block_given? && (_value = instance_exec(&block))
 						AST::Literal.new _name, _value, _options
 					end
 				end

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

@@ -4,44 +4,42 @@ module CloudSesame
 			module AppliedFilterQuery
 
 				def included?(field, value = nil)
-					!!(
-						(field_options = _context[:fields][field.to_sym]) &&
-						(applied = field_options[:applied]) &&
-						(
-							(!value && applied.values.any?) ||
-							(
-								value && (index = applied.keys.index(value)) &&
-								(field_options[:applied].values[index] != false)
-							)
-						)
-					)
+					return false unless (options = field_options_for(field)) && (applied = options[:applied])
+					if value
+						(index = applied.keys.index(value)) &&
+						(applied.values[index] != false)
+					else
+						applied.values.any?
+					end
 				end
 
 				def excluded?(field, value = nil)
-					!!(
-						(field_options = _context[:fields][field.to_sym]) &&
-						(applied = field_options[:applied]) &&
-						(
-							(!value && !applied.values.all?) ||
-							(
-								value && (index = applied.keys.index(value)) &&
-								field_options[:applied].values[index] == false
-							)
-						)
-					)
+					return false unless (options = field_options_for(field)) && (applied = options[:applied])
+					if value
+						(index = applied.keys.index(value)) &&
+						(applied.values[index] == false)
+					else
+						!applied.values.all?
+					end
 				end
 
 				def applied_filters
 					applied = {}
 					_context[:fields].each do |field, options|
 						if options && options[:applied] &&
-							!(values = options[:applied].select { |k, v| v }.keys).empty?
+							!(values = options[:applied].select { |_, v| v }.keys).empty?
 							applied[field] = values
 						end
 					end
 					applied
 				end
 
+				private
+
+				def field_options_for(field)
+					_context[:fields][field.to_sym]
+				end
+
 			end
 		end
 	end

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

@@ -3,15 +3,20 @@ module CloudSesame
 		module DSL
 			module FieldAccessors
 
+				def self.__define_accessor__(name)
+					define_method(name) { |*values, &block| literal name, *values, &block }
+				end
+
 				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
+						domain = Domain::Literal.new(name, options, caller)
+						node = domain._eval(&block)
+						values << node
+					end
 
 			  	_scope.children.field = name
 			  	_scope.children._return = _return

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

@@ -19,11 +19,11 @@ module CloudSesame
 				end
 
 				def each(&block)
-					results.each &block
+					results.each(&block)
 				end
 
 				def map(&block)
-					results.map &block
+					results.map(&block)
 				end
 
 				def search