CloudSesame 0.1.0

data/lib/cloud_sesame/domain/config.rb

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

data/lib/cloud_sesame/domain/context.rb

@@ -0,0 +1,35 @@
+module CloudSesame
+  module Domain
+    class Context
+
+      attr_reader :table
+
+      def initialize(table = {})
+        @table = table
+      end
+
+      def [](key, find_or_create = false)
+        table[key] ||= default_value(find_or_create)
+      end
+
+      def []=(key, value)
+        table[key] = value
+      end
+
+      def each(&block)
+        table.each &block
+      end
+
+      def map(&block)
+        table.map &block
+      end
+
+      private
+
+      def default_value(data)
+        data != true ? data : Context.new if data
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module CloudSesame
+  module Query
+    module AST
+      class And < Operator
+        self.symbol = :and
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module CloudSesame
+  module Query
+    module AST
+      class CompoundArray < Array
+        # include Range
+
+        attr_accessor :scope, :parent, :literal
+        attr_reader :field
+
+        def field=(field)
+          self.parent = nil
+          self.literal = AST::Literal
+          @field = field
+        end
+
+        def set_scope(scope)
+          self.scope = scope
+          return self
+        end
+
+        # SINGLE BRANCH OPERATOR
+        # =======================================
+        def not(*values)
+          self.parent = AST::Not
+          self.literal = AST::Literal
+          insert_children(values)
+          return self
+        end
+
+        alias_method :is_not, :not
+
+        # PREFIX LITERAL
+        # =======================================
+        def prefix(*values)
+          self.literal = AST::PrefixLiteral
+          insert_children(values)
+          return self
+        end
+
+        alias_method :start_with, :prefix
+        alias_method :begin_with, :prefix
+
+        # RANGE LITERAL
+        # =======================================
+        # def range
+        #   self.literal = AST::PrefixLiteral
+        #   insert_children(values)
+        #   return self
+        # end
+
+        # alias_method :start_with, :prefix
+
+        def insert_children(values = [])
+          values.each do |value|
+            if parent
+              self << (node = parent.new scope.context)
+              node.child = literal.new(field, value, options)
+            else
+              self << literal.new(field, value, options)
+            end
+          end
+        end
+
+        private
+
+        def options
+          scope.context[:fields][field]
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module CloudSesame
+  module Query
+    module AST
+      class Leaf
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module CloudSesame
+  module Query
+    module AST
+      class Literal < SingleBranch
+
+        attr_accessor :field
+        attr_reader :value, :options
+
+        def initialize(field, value, options = {})
+          @field = field
+          @value = Value.new(value)
+          @options = options
+          (options[:included] ||= []) << value
+        end
+
+        def value=(value)
+          @value = Value.new(value)
+        end
+
+        def compile
+          "#{ field }:#{ value.compile }"
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module CloudSesame
+  module Query
+    module AST
+      class MultiBranch
+        include DSL::Base
+        include DSL::FilterQuery
+        include DSL::Scope
+
+        attr_reader :context
+
+        def initialize(context, &block)
+          @context = context
+          instance_eval &block if block_given?
+        end
+
+        def children
+          @children ||= CompoundArray.new.set_scope self
+        end
+
+        def compile_children
+          children.map(&:compile).join(' ')
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module CloudSesame
+  module Query
+    module AST
+      class Not < SingleBranch
+
+      	def compile
+				"(not #{ child.compile })"
+      	end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module CloudSesame
+  module Query
+    module AST
+      class Operator < MultiBranch
+
+        # 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  } #{ compile_children })" unless children.empty?
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module CloudSesame
+  module Query
+    module AST
+      class Or < Operator
+        self.symbol = :or
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module CloudSesame
+  module Query
+    module AST
+      class PrefixLiteral < Literal
+
+        def compile
+          "(prefix field=#{ escape(field) } #{ value.compile })"
+        end
+
+        def escape(data = "")
+          "'#{ data.to_s.gsub(/\'/) { "\\'" } }'"
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module CloudSesame
+  module Query
+    module AST
+      class Root < MultiBranch
+
+        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
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module CloudSesame
+  module Query
+    module AST
+      class SingleBranch
+
+        attr_accessor :child
+      	attr_reader :context
+
+      	def initialize(context, &block)
+      	  @context = context
+      	  instance_eval &block if block_given?
+      	end
+
+        def child=(object)
+          if object.kind_of? Literal
+            (object.options[:excluded] ||= []) << object.options[:included].delete(object.value.data)
+          end
+          @child = object
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module CloudSesame
+  module Query
+    module AST
+      class Value < Leaf
+
+        attr_accessor :data
+
+        def initialize(data)
+          @data = data
+        end
+
+        def compile
+          format(data)
+        end
+
+        private
+
+        def format(data)
+          range?(data) || digits?(data) ? data : escape(data)
+        end
+
+        def range?(data)
+          data =~ /^[\[\{].*[\]\}]$/
+        end
+
+        def digits?(data)
+          data.to_s =~ /^\d+(.\d+)?$/
+        end
+
+        # "hello" => "'hello'"
+        def escape(data = "")
+          "'#{ data.to_s.gsub(/\'/) { "\\'" } }'"
+        end
+
+      end
+    end
+  end
+end

data/lib/cloud_sesame/query/builder.rb

@@ -0,0 +1,78 @@
+module CloudSesame
+	module Query
+		class Builder
+			include DSL::Base
+			include DSL::FilterQuery
+
+			attr_accessor :context, :searchable_class
+
+			def initialize(default_context, searchable_class)
+				@context = default_context
+				@searchable_class = searchable_class
+			end
+
+			def request
+				@request ||= Node::Request.new context.dup
+			end
+
+			def reset
+				@request = nil
+			end
+
+			def inspect
+				"#<CloudSesame::Query::Builder:#{ object_id } #{ request.compile }>"
+			end
+
+			# CHAINABLE METHODS
+			# =========================================
+
+			def query(string)
+				request.query.query = string
+				return self
+			end
+
+			def terms(*terms)
+				request.query.terms.concat terms
+				return self
+			end
+
+			def exclude_terms(*terms)
+				request.query.terms.concat terms.map { |t| "-#{ t }" }
+				return self
+			end
+
+			def page(value)
+				request.page.page = value.to_i
+				return self
+			end
+
+			def size(value)
+				request.page.size = value.to_i
+				return self
+			end
+
+			def sort(hash = {})
+				hash.each { |key, value| request.sort[key] = value }
+				return self
+			end
+
+			# ENDING METHODS
+			# =========================================
+
+			def search
+				compiled = request.compile
+				raise Error::MissingQuery.new("Query can not be empty!") unless compiled[:query] && !compiled[:query].empty?
+				result = searchable_class.cloudsearch.client.search compiled
+				reset
+				result
+			end
+
+			private
+
+			def method_scope
+				request.filter_query.root
+			end
+
+		end
+	end
+end

data/lib/cloud_sesame/query/dsl.rb

@@ -0,0 +1,62 @@
+# module CloudSesame
+#   module Query
+#     module DSL
+
+#       # CLAUSE: AND
+#       # =========================================
+#       def and(&block)
+#         filter_query.children << AST::And.new(context, &block)
+#         return filter_query
+#       end
+
+#       alias_method :all,  :and
+#       alias_method :and!, :and
+#       alias_method :+,    :and
+
+#       # CLAUSE: OR
+#       # =========================================
+#       def or(&block)
+#         filter_query.children << AST::Or.new(context, &block)
+#         return filter_query
+#       end
+
+#       alias_method :any, :or
+#       alias_method :or!, :or
+
+#       # CLAUSE: LITERAL
+#       # =========================================
+#       def literal(field, value, options = {})
+#         node = AST::Literal.new(field, value, options)
+#         filter_query.children << node
+#         node
+#       end
+
+#       def prefix(literals)
+#         literals.each { |literal| literal.options[:prefix] = true }
+#         return filter_query
+#       end
+
+#       private
+
+#       def filter_query
+#         self
+#       end
+
+#       def scopes
+#         filter_query.context[:scopes]
+#       end
+
+#       def method_missing(field, *values, &block)
+#         if context[:fields] && (options = context[:fields][field])
+#           values.map { |value| literal(field, value, options) }
+#         elsif scope && (callback = scope[field])
+#           filter_query.instance_exec *values, &callback
+#           return filter_query
+#         else
+#           super
+#         end
+#       end
+
+#     end
+#   end
+# end