CloudSesame 0.6.8 → 0.7.0

data/lib/cloud_sesame/config/credential.rb

@@ -1,8 +1,8 @@
 module CloudSesame
-	module Config
-		class Credential < ::AbstractObject
-			accept :access_key_id, as: [:access_key]
-			accept :secret_access_key, as: [:secret_key]
-		end
-	end
+  module Config
+    class Credential < ::AbstractObject
+      accept :access_key_id, as: [:access_key]
+      accept :secret_access_key, as: [:secret_key]
+    end
+  end
 end

data/lib/cloud_sesame/context.rb

@@ -23,10 +23,5 @@ module CloudSesame
       table[key.to_sym] = value
     end
 
-    def duplicate(context)
-      @table = context.table.deep_dup
-      self
-    end
-
   end
 end

data/lib/cloud_sesame/domain/base.rb

@@ -1,130 +1,149 @@
 module CloudSesame
-	module Domain
-		class Base
-			extend Forwardable
-
-			def_delegators :client, :config, :caching_with
-
-			attr_reader :searchable
-
-			def self.definitions
-				@definitions ||= {}
-			end
-
-			def initialize(searchable)
-				@searchable = searchable
-			end
-
-			def builder
-				Query::Builder.new context, searchable
-			end
-
-			def client
-				@client ||= Client.new searchable
-			end
-
-			def context
-				@context ||= Context.new
-			end
-
-			# DEFAULT CONTEXT METHODS
-			# =========================================
-
-			def default_size(value)
-				page[:size] = value.to_i
-			end
-
-			def define_sloppiness(value)
-				query[:sloppiness] = Query::Node::Sloppiness.new(value)
-			end
-
-			def define_fuzziness(&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)) 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?
-				filter_query_scopes[name.to_sym] = block if block
-			end
-
-			private
-
-			def to_hash(options)
-				options.is_a?(Hash) ? options : {}
-			end
-
-			def add_query(name, options)
-				((context[:query_options] ||= {})[:fields] ||= {})[name] = to_hash(options)
-			end
-
-			def add_facet(name, options)
-				(context[:facet] ||= {})[name] = to_hash(options)
-			end
-
-			def add_field(name, options)
-				options = merge_with_as_field options if options[:as]
-				create_default_literal name, options
-				create_field_accessor name
-				filter_query_fields[name] = options
-			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"
-					domain = Query::Domain::Literal.new(name, options, caller)
-					node = domain._eval(&block)
-					filter_query_defaults << node if node
-				end
-			end
-
-			def create_field_accessor(name)
-				Query::DSL::FieldAccessors.__define_accessor__(name)
-			end
-
-			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
-
-			# 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
-	end
+  module Domain
+    class Base
+      extend Forwardable
+
+      def_delegators :client, :config, :caching_with
+
+      attr_reader :searchable
+
+      def self.definitions
+        @definitions ||= {}
+      end
+
+      def initialize(searchable)
+        @searchable = searchable
+        @builder = Query::Builder.construct_class(searchable)
+      end
+
+      def builder
+        @builder.new context, searchable
+      end
+
+      def client
+        @client ||= Client.new searchable
+      end
+
+      def context
+        @context ||= Context.new
+      end
+
+      # DEFAULT CONTEXT METHODS
+      # =========================================
+
+      def default_size(value)
+        context_page[:size] = value.to_i
+      end
+
+      def define_sloppiness(value)
+        context_query[:sloppiness] = Query::Node::Sloppiness.new(value)
+      end
+
+      def define_fuzziness(&block)
+        context_query[:fuzziness] = Query::Node::Fuzziness.new(&block)
+      end
+
+      def field(name, options = {})
+        field_name = (options[:as] || name).to_sym
+
+        add_sort_alias(name, options) if options[:as]
+        add_query_options(field_name, options) if options[:query]
+        add_facet(field_name, options) if options[:facet]
+        add_field(name, options)
+      end
+
+      def scope(name, proc = nil, &block)
+        block = proc unless block_given?
+        filter_query_scopes[name.to_sym] = block if block
+      end
+
+      private
+
+      def add_sort_alias(name, options)
+        context_sort_fields[name] = { as: options[:as] }
+      end
+
+      def add_query_options(name, options)
+        context_query_options[name] = to_hash(options.delete(:query))
+      end
+
+      def add_facet(name, options)
+        context_facet[name] = to_hash(options.delete(:facet))
+      end
+
+      def add_field(name, options)
+        options = merge_with_as_field options if options[:as]
+        options[:type] = set_type(options[:type])
+        create_accessor name
+        create_default_literal name, options
+        filter_query_fields[name] = options
+      end
+
+      def set_type(type)
+        Query::AST::Value.map_type(type)
+      end
+
+      def merge_with_as_field(options)
+        (existing = filter_query_fields.delete(options[:as])) ? existing.merge(options) : options
+      end
+
+      def create_accessor(name)
+        @builder.field_accessor.__define_accessor__(name)
+      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 if node
+        end
+      end
+
+      def to_hash(options)
+        options.is_a?(Hash) ? options : {}
+      end
+
+      def method_missing(name, *args, &block)
+        builder.respond_to?(name) ? builder.send(name, *args, &block) :
+        searchable.respond_to?(name) ? searchable.send(name, *args, &block) :
+        super
+      end
+
+      # CONTEXT INITIALIZERS
+      # =========================================
+
+      def context_page
+        context[:page] ||= {}
+      end
+
+      def context_query
+        context[:query] ||= {}
+      end
+
+      def context_query_options
+        (context[:query_options] ||= {})[:fields] ||= {}
+      end
+
+      def context_facet
+        context[:facet] ||= {}
+      end
+
+      def context_sort_fields
+        (context[:sort] ||= {})[:fields] ||= {}
+      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
+  end
 end

data/lib/cloud_sesame/domain/client.rb

@@ -1,38 +1,38 @@
 require 'cloud_sesame/domain/client_module/caching'
 
 module CloudSesame
-	module Domain
-		class Client
-			include ClientModule::Caching
+  module Domain
+    class Client
+      include ClientModule::Caching
 
-			attr_reader :searchable
+      attr_reader :searchable
 
-			def self.configure
-				yield global_config if block_given?
-			end
+      def self.configure
+        yield global_config if block_given?
+      end
 
-			def self.global_config
-				@global_config ||= Config.new
-			end
+      def self.global_config
+        @global_config ||= Config.new
+      end
 
-			def initialize(searchable)
-				@searchable = searchable
-			end
+      def initialize(searchable)
+        @searchable = searchable
+      end
 
-			def config
-				@config ||= Config.new self.class.global_config
-			end
+      def config
+        @config ||= Config.new self.class.global_config
+      end
 
-			def search(params)
-				executor.fetch params
-			end
+      def search(params)
+        executor.fetch params
+      end
 
-			private
+      private
 
-			def aws_client
-				@aws_client ||= ::Aws::CloudSearchDomain::Client.new config.to_hash
-			end
+      def aws_client
+        @aws_client ||= LazyObject.new { ::Aws::CloudSearchDomain::Client.new config.to_hash }
+      end
 
-		end
-	end
+    end
+  end
 end

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

@@ -1,30 +1,26 @@
 module CloudSesame
-	module Domain
-		module ClientModule
-			module Caching
-				class Base
+  module Domain
+    module ClientModule
+      module Caching
+        class Base
 
-					def initialize(searchable, &lazy_client)
-						@searchable = searchable
-						@lazy_client = lazy_client
-					end
+          def initialize(client, searchable)
+            @client = client
+            @searchable = searchable
+          end
 
-					def client
-						@client ||= @lazy_client.call
-					end
+          def fetch(_params)
+            raise Error::Caching, "Caching Module needs #fetch method and accepts params"
+          end
 
-					def fetch(_params)
-						raise Error::Caching, "Caching Module needs #fetch method and accepts params"
-					end
+          private
 
-					private
+          def search(params)
+            @client.search params
+          end
 
-					def search(params)
-						client.search params
-					end
-
-				end
-			end
-		end
-	end
+        end
+      end
+    end
+  end
 end

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

@@ -1,15 +1,15 @@
 module CloudSesame
-	module Domain
-		module ClientModule
-			module Caching
-				class NoCache < Base
+  module Domain
+    module ClientModule
+      module Caching
+        class NoCache < Base
 
-					def fetch(params)
-						search params
-					end
+          def fetch(params)
+            search params
+          end
 
-				end
-			end
-		end
-	end
+        end
+      end
+    end
+  end
 end

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

@@ -1,38 +1,42 @@
 require 'ostruct'
 
 module CloudSesame
-	module Domain
-		module ClientModule
-			module Caching
-				class RailsCache < Base
+  module Domain
+    module ClientModule
+      module Caching
+        class RailsCache < Base
 
-					def initialize(searchable, &lazy_client)
-						ensure_environment_exists
-						super
-					end
+          def initialize(client, searchable)
+            ensure_environment_exists
+            super
+          end
 
-					def fetch(params)
-						Rails.cache.fetch(hashify(params)) do
-							results = search params
-							OpenStruct.new(status: results.status, hits: results.hits, facets: results.facets)
-						end
-					end
+          def fetch(params)
+            Rails.cache.fetch(hexdigest(params)) do
+              results = search params
+              OpenStruct.new(
+                status: results.status,
+                hits: results.hits,
+                facets: results.facets
+              )
+            end
+          end
 
-					private
+          private
 
-					def hashify(params)
-						searchable_params = params.merge(searchable: @searchable)
-						Digest::MD5.hexdigest Marshal.dump(searchable_params)
-					end
+          def hexdigest(params)
+            searchable_params = params.merge(searchable: @searchable)
+            Digest::MD5.hexdigest Marshal.dump(searchable_params)
+          end
 
-					def ensure_environment_exists
-						unless RailsCache.const_defined?(:Rails)
-							raise Error::Caching, "Rails environment cannot be found"
-						end
-					end
+          def ensure_environment_exists
+            unless RailsCache.const_defined?(:Rails)
+              raise Error::Caching, "Rails environment cannot be found"
+            end
+          end
 
-				end
-			end
-		end
-	end
+        end
+      end
+    end
+  end
 end

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

@@ -3,38 +3,29 @@ require_relative './caching/no_cache'
 require_relative './caching/rails_cache'
 
 module CloudSesame
-	module Domain
-		module ClientModule
-			module Caching
+  module Domain
+    module ClientModule
+      module Caching
 
-				def caching_with(caching_module)
-					unrecognized_caching_module if !module_defined?(caching_module)
-					self.executor = module_get(caching_module)
-				end
+        def caching_with(klass)
+          self.executor = klass.is_a?(Class) ? klass : module_get(klass)
+        end
 
-				def executor
-					@executor ||= Caching::NoCache.new(@searchable) { aws_client }
-				end
+        def executor
+          @executor ||= Caching::NoCache.new(aws_client, @searchable)
+        end
 
-				def executor=(executor)
-					@executor = executor.new(@searchable) { aws_client }
-				end
+        def executor=(executor)
+          @executor = executor.new(aws_client, @searchable)
+        end
 
-				private
+        private
 
-				def module_defined?(caching_module)
-					ClientModule::Caching.const_defined? caching_module
-				end
+        def module_get(klass)
+          ClientModule::Caching.const_get klass, false
+        end
 
-				def module_get(caching_module)
-					ClientModule::Caching.const_get caching_module
-				end
-
-				def unrecognized_caching_module
-					raise Error::Caching, "Unrecognized Caching Module"
-				end
-
-			end
-		end
-	end
+      end
+    end
+  end
 end

data/lib/cloud_sesame/domain/client_module/retry.rb

@@ -1,9 +1,9 @@
 module CloudSesame
-	module Domain
-		module ClientModule
-			module Retry
+  module Domain
+    module ClientModule
+      module Retry
 
-			end
-		end
-	end
+      end
+    end
+  end
 end

data/lib/cloud_sesame/domain/config.rb

@@ -1,8 +1,8 @@
 module CloudSesame
-	module Domain
-		class Config < CloudSesame::Config::Credential
-			accept :sigv4_region, as: [:region]
-			accept :endpoint, as: [:search_endpoint]
-		end
-	end
+  module Domain
+    class Config < CloudSesame::Config::Credential
+      accept :sigv4_region, as: [:region]
+      accept :endpoint, as: [:search_endpoint]
+    end
+  end
 end

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

@@ -0,0 +1,37 @@
+module CloudSesame
+  module Query
+    module AST
+      module Abstract
+        class MultiExpressionOperator < Operator
+
+          def <<(object)
+            children << object
+          end
+
+          def applied(included = true)
+            children.map { |child| child.applied(included) }
+          end
+
+          def children
+            @children ||= build_children
+          end
+
+          def compile
+            if !children.empty? && (compiled = children.compile) && !compiled.empty?
+              "(#{ symbol  }#{ boost } #{ compiled })"
+            end
+          end
+
+          private
+
+          def build_children
+            (children = FieldArray.new)._scope = self
+            children
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module CloudSesame
+  module Query
+    module AST
+      module Abstract
+        class Operator
+          SYMBOL = nil
+
+          attr_reader :context, :options
+
+          def initialize(context, options = {})
+            @context = context
+            @options = options
+          end
+
+          def boost
+            " boost=#{ options[:boost] }" if options[:boost]
+          end
+
+          def symbol
+            self.class::SYMBOL
+          end
+
+        end
+      end
+    end
+  end
+end