CloudSesame 0.6.8 → 0.7.0

data/lib/cloud_sesame/query/builder.rb

@@ -1,56 +1,85 @@
 module CloudSesame
-	module Query
-		class Builder
-			include DSL::QueryMethods
-			include DSL::ResponseMethods
-			include DSL::BlockStyledOperators
-			include DSL::FieldAccessors
-			include DSL::ScopeAccessors
-			include DSL::AppliedFilterQuery
-			include DSL::PageMethods
-			include DSL::SortMethods
-			include DSL::ReturnMethods
-
-			attr_reader :context, :searchable
-
-			def initialize(context, searchable)
-				@context = Context.new.duplicate context
-				@searchable = searchable
-			end
-
-			def request
-				@request ||= Node::Request.new context
-			end
-
-			def compile
-				request.compile
-			end
-
-			def inspect
-				"#<#{ self.class }:#{ object_id } #{ compile }>"
-			end
-
-			private
-
-			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 _context
-				_scope.context
-			end
-
-			def _return
-				self
-			end
-
-		end
-	end
+  module Query
+    class Builder
+      extend ClassSpecific
+      include DSL::AppliedFilterQuery
+      include DSL::BlockStyledOperators
+      include DSL::InspectMethod
+      include DSL::PageMethods
+      include DSL::QueryMethods
+      include DSL::ResponseMethods
+      include DSL::ReturnMethods
+      include DSL::ScopeAccessors
+      include DSL::SortMethods
+
+      # ClassSpecific construct class callback
+      #
+      # after construct searchable specific builder,
+      # construct searchable specific DSL::FieldAccessors,
+      # and Domain::Block and include the new field accessors
+      # in both builder and domain block
+      # ===================================================
+      after_construct do |searchable|
+        @field_accessor = DSL::FieldAccessors.construct_module(searchable)
+        @block_domain = Domain::Block.construct_class(searchable, callback_args: [field_accessor])
+        @request = Node::Request.construct_class(searchable)
+
+        include field_accessor
+      end
+
+      # Domain::Block getter
+      def self.block_domain
+        @block_domain ||= Domain::Block
+      end
+
+      # Node::Request getter
+      def self.request
+        @request ||= Node::Request
+      end
+
+      # DSL::FieldAccessors getter
+      def self.field_accessor
+        @field_accessor ||= DSL::FieldAccessors
+      end
+
+      # ===================================================
+
+      attr_reader :context, :searchable
+
+      def initialize(context, searchable)
+        @context = context
+        @searchable = searchable
+      end
+
+      def request
+        @request ||= self.class.request.new context
+      end
+
+      def compile
+        request.compile
+      end
+
+      private
+
+      def _block_domain(block)
+        if block
+          caller = block.binding.eval("self")
+          self.class.block_domain.new caller, _context
+        end
+      end
+
+      def _scope
+        request.filter_query.root
+      end
+
+      def _context
+        _scope.context
+      end
+
+      def _return
+        self
+      end
+
+    end
+  end
 end

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

@@ -2,14 +2,16 @@ module CloudSesame
 	module Query
 		module Domain
 			class Block
+				extend ClassSpecific
 				include DSL::AppliedFilterQuery
 				include DSL::BlockStyledOperators
-				include DSL::FieldAccessors
         include DSL::Operators
         include DSL::RangeHelper
         include DSL::ScopeAccessors
         include DSL::BindCaller
 
+        after_construct { |_, field_accessor| include field_accessor }
+
 				attr_reader :_caller, :_context, :_scopes
 
 				def initialize(_caller, _context)

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

@@ -4,42 +4,33 @@ module CloudSesame
 			module AppliedFilterQuery
 
 				def included?(field, value = nil)
-					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
+					applied?(field, value, true)
 				end
 
 				def excluded?(field, value = nil)
-					return false unless (options = field_options_for(field)) && (applied = options[:applied])
+					applied?(field, value, false)
+				end
+
+				def applied?(field, value, included = nil)
+					field = field.to_sym
+					applied = applied_filters(included)
 					if value
-						(index = applied.keys.index(value)) &&
-						(applied.values[index] == false)
+						applied[field] && applied[field].include?(value)
 					else
-						!applied.values.all?
+						applied[field] && !applied[field].empty?
 					end
 				end
 
-				def applied_filters
-					applied = {}
-					_context[:fields].each do |field, options|
-						if options && options[:applied] &&
-							!(values = options[:applied].select { |_, v| v }.keys).empty?
-							applied[field] = values
+				def applied_filters(included = nil)
+					applied = Hash.new { |hash, key| hash[key] = [] }
+					_scope.applied.flatten!.compact!.each do |result|
+						if included.nil? || result[:included] == included
+							applied[result[:field]] << result[:value]
 						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

@@ -1,29 +1,32 @@
 module CloudSesame
-	module Query
-		module DSL
-			module FieldAccessors
+  module Query
+    module DSL
+      module FieldAccessors
+        extend ClassSpecific
 
-				def self.__define_accessor__(name)
-					define_method(name) { |*values, &block| literal name, *values, &block }
-				end
+        def self.__define_accessor__(name)
+          define_method name do |*values, &block|
+            literal name, *values, &block
+          end
+        end
 
-				def literal(name, *values, &block)
-					name = name.to_sym
+        def literal(name, *values, &block)
+          name = name.to_sym
+          values << __literal_block_handler__(name, block) if block_given?
+          _scope.children.field = name
+          _scope.children._return = _return
+          _scope.children.insert values
+        end
 
-					if block_given?
-						caller = block.binding.eval "self"
-						options = _scope.context[:fields][name]
-						domain = Domain::Literal.new(name, options, caller)
-						node = domain._eval(&block)
-						values << node
-					end
+        private
 
-			  	_scope.children.field = name
-			  	_scope.children._return = _return
-			  	_scope.children.insert values
-				end
+        def __literal_block_handler__(name, block)
+          caller = block.binding.eval "self"
+          options = _scope.context[:fields][name]
+          Domain::Literal.new(name, options, caller)._eval(&block)
+        end
 
-			end
-		end
-	end
+      end
+    end
+  end
 end

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

@@ -60,7 +60,7 @@ module CloudSesame
 				end
 
 				def build_literal(value)
-					if value.kind_of?(AST::SingleExpressionOperator) || value.is_a?(AST::Literal)
+					if value.kind_of?(AST::Abstract::SingleExpressionOperator) || value.is_a?(AST::Literal)
 						value.is_for field, _context[:fields][field]
 						value
 					else

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

@@ -0,0 +1,31 @@
+module CloudSesame
+	module Query
+		module DSL
+			module InspectMethod
+
+				def inspect
+					string = green("#<#{ self.class }:#{ object_id }\n{")
+
+					string << compile.map { |k, v| "#{ green(k) } => #{ yellow(v) }" }.join(",\n ")
+					string << green('}')
+					string
+				end
+
+				private
+
+				def green(string)
+					color(32, string)
+				end
+
+				def yellow(string)
+					color(33, string)
+				end
+
+				def color(code, string)
+					"\e[#{ code }m#{ string }\e[0m"
+				end
+
+			end
+		end
+	end
+end

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

@@ -4,15 +4,16 @@ module CloudSesame
 			module SortMethods
 
 				def sort(input = false)
-					if input.is_a? Hash
-						request.sort.sorting_attributes = input
+					if input.is_a?(Hash)
+						request.sort.attributes = input
 						return self
 					elsif input
-						request.sort[input]
+						request.sort[input] = nil
+						return self
 					elsif input.nil?
 						return self
 					else
-						request.sort.sorting_attributes
+						request.sort.attributes
 					end
 				end
 

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

@@ -5,9 +5,8 @@ module CloudSesame
         attr_reader :context
 
         def initialize(context)
-          @context = context
+          @context = context || {}
         end
-
       end
     end
   end

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

@@ -3,12 +3,8 @@ module CloudSesame
     module Node
       class Facet < Abstract
 
-        def facet
-          @facet ||= context
-        end
-
         def compile
-          { facet: JSON.dump(facet) } unless facet.empty?
+          JSON.dump(context) if context && !context.empty?
         end
 
       end

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

@@ -3,12 +3,25 @@ module CloudSesame
     module Node
       class FilterQuery < Abstract
 
+        EXCESS_WHITESPACES = Regexp.new(/\s{2,}/).freeze
+        ENDING_WHITESPACES = Regexp.new(/\s+\)$/).freeze
+
         def compile
-          { filter_query: root.compile }
+          if (compiled = root.compile) && !(compiled = strip(compiled)).empty?
+            compiled
+          end
         end
 
         def root
-          @root ||= CloudSesame::Query::AST::Root.new context
+          @root ||= AST::Root.new context
+        end
+
+        private
+
+        def strip(string)
+          string.gsub!(EXCESS_WHITESPACES, ' '.freeze)
+          string.gsub!(ENDING_WHITESPACES, ')'.freeze)
+          string
         end
 
       end

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

@@ -3,7 +3,7 @@ module CloudSesame
     module Node
       class Fuzziness
 
-        EXCLUDING_TERMS = /^\-/
+        EXCLUDING_TERMS = /^\-/.freeze
 
         def initialize(&block)
 
@@ -28,13 +28,14 @@ module CloudSesame
         end
 
         def compile(string)
-          "(#{ each_word_in(string) { |word| fuzziness(word) }.compact.join('+') })"
+          (compiled = each_word_in(string) { |word| fuzziness(word) }).compact!
+          "(#{ compiled.join('+') })"
         end
 
         private
 
         def each_word_in(string, &block)
-          string.split(' ').map(&block)
+          string.split(' ').map!(&block)
         end
 
         def fuzziness(word)

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

@@ -6,11 +6,11 @@ module CloudSesame
 				attr_writer :page, :size, :start
 
         def page
-					@page ||= context[:page] || 1
+					@page ||= 1
         end
 
 				def size
-					@size ||= context[:size] || 10
+					@size ||= (context && context[:size]) || 10
 				end
 
 				def start

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

@@ -2,37 +2,24 @@ module CloudSesame
 	module Query
 		module Node
 			class Query < Abstract
+				extend ClassSpecific
 
-				attr_writer :query
-
-				def query
-					@query ||= context[:query]
-				end
+				attr_accessor :query
 
 				def compile
 					if query && !query.empty?
 						compiled = "(#{ query })"
 
-						[fuzziness, sloppiness].each do |parser|
+						[context[:fuzziness], context[:sloppiness]].each do |parser|
 							if parser && (parsed = parser.compile(query))
 								compiled << "|" << parsed
 							end
 						end
 
-						{ query: compiled }
+						compiled
 					end
 				end
 
-				private
-
-				def fuzziness
-					context[:fuzziness]
-				end
-
-				def sloppiness
-					context[:sloppiness]
-				end
-
 			end
 		end
 	end

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

@@ -4,31 +4,21 @@ module CloudSesame
       class QueryOptions < Abstract
 
         def fields
-          @fields ||= default_fields
+          @fields ||= build(context[:fields])
         end
 
         def compile
-          {
-            query_options: JSON.dump({
-              fields: compile_fields
-            })
-          } unless fields.empty?
+          JSON.dump({ fields: fields.map(&:compile) }) unless fields.empty?
         end
 
         private
 
-        def compile_fields
-          fields.map(&:compile)
+        def build(fields)
+          fields ? fields.map { |field, opt| build_field(field, opt) } : []
         end
 
-        def default_fields
-          if context[:fields]
-            context[:fields].map do |field, options|
-              QueryOptionsField.new field, options[:weight]
-            end
-          else
-            []
-          end
+        def build_field(field, options)
+          QueryOptionsField.new field, options[:weight]
         end
 
       end

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

@@ -11,7 +11,9 @@ module CloudSesame
         end
 
         def compile
-          "#{ field }#{ '^' + weight.to_s if weight }"
+          compiled = field.to_s
+          compiled << '^' << weight.to_s if weight
+          compiled
         end
 
       end

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

@@ -3,22 +3,20 @@ module CloudSesame
     module Node
       class QueryParser < Abstract
 
-        TYPES = %w(simple structured lucene dismax)
-
-        attr_writer :type
+        def type
+          @type ||= "simple"
+        end
 
-        TYPES.each do |type|
-          define_method type do
-            self.type = type; self
-          end
+        def simple
+          @type = "simple"
         end
 
-        def type
-          @type ||= (context[:query_parser] || :simple).to_s
+        def structured
+          @type = "structured"
         end
 
         def compile
-          { query_parser: type.to_s }
+          type.to_s
         end
 
       end