elasticsearch-dsl 0.0.0 → 0.1.0

data/lib/elasticsearch/dsl/search/aggregations/value_count.rb

@@ -0,0 +1,25 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Aggregations
+
+        # A single-value metric aggregation which returns the number of values for the aggregation scope
+        #
+        # @example
+        #
+        #     search do
+        #       aggregation :value_count do
+        #         value_count field: 'clicks'
+        #       end
+        #     end
+        #
+        # @see http://elasticsearch.org/guide/en/elasticsearch/reference/current/search-aggregations-metrics-valuecount-aggregation.html
+        #
+        class ValueCount
+          include BaseComponent
+        end
+
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/base_aggregation_component.rb

@@ -0,0 +1,65 @@
+module Elasticsearch
+  module DSL
+    module Search
+
+      # Module containing common functionality for aggregation DSL classes
+      #
+      module BaseAggregationComponent
+
+        def self.included(base)
+          base.__send__ :include, BaseComponent
+          base.__send__ :include, InstanceMethods
+        end
+
+        module InstanceMethods
+
+          attr_reader :aggregations
+
+          # Looks up the corresponding class for a method being invoked, and initializes it
+          #
+          # @raise [NoMethodError] When the corresponding class cannot be found
+          #
+          def method_missing(name, *args, &block)
+            klass = Utils.__camelize(name)
+            if Aggregations.const_defined? klass
+              @value = Aggregations.const_get(klass).new *args, &block
+            else
+              raise NoMethodError, "undefined method '#{name}' for #{self}"
+            end
+          end
+
+          # Adds a nested aggregation into the aggregation definition
+          #
+          # @return [self]
+          #
+          def aggregation(*args, &block)
+            @aggregations ||= {}
+            @aggregations.update args.first => Aggregation.new(*args, &block)
+            self
+          end
+
+          # Convert the aggregations to a Hash
+          #
+          # A default implementation, DSL classes can overload it.
+          #
+          # @return [Hash]
+          #
+          def to_hash(options={})
+            call
+
+            @hash = { name => @args } unless @hash && @hash[name] && ! @hash[name].empty?
+
+            if @aggregations
+              @hash[:aggregations] = {}
+              @aggregations.map { |name, value| @hash[:aggregations][name] = value.to_hash }
+            end
+            @hash
+          end
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/elasticsearch/dsl/search/base_component.rb

@@ -0,0 +1,162 @@
+module Elasticsearch
+  module DSL
+    module Search
+
+      # Module containing common functionality for DSL classes
+      #
+      module BaseComponent
+        def self.included(base)
+          base.__send__ :extend,  ClassMethods
+          base.__send__ :include, InstanceMethods
+
+          base.instance_eval do
+            #   Defines an "inner" method for DSL classes
+            #
+            #     @example Define a method `bar` for the MyQuery class which updates the query definition
+            #
+            #         class MyQuery
+            #           include BaseComponent
+            #
+            #           option_method :bar
+            #         end
+            #
+            #         q = MyQuery.new :foo do
+            #           bar 'TEST'
+            #         end
+            #
+            #         q.to_hash
+            #         # => {:myquery=>{:foo=>{:bar=>"TEST"}}}
+            #
+            #     @example Define a method `bar` with custom logic for updating the Hash with query definition
+            #
+            #         class MyCustomQuery
+            #           include BaseComponent
+            #
+            #           option_method :bar, lambda { |*args| @hash[self.name.to_sym][@args].update custom: args.pop }
+            #         end
+            #
+            #         q = MyCustomQuery.new :foo do
+            #           bar 'TEST'
+            #         end
+            #
+            #         q.to_hash
+            #       # => {:mycustomquery=>{:foo=>{:custom=>"TEST"}}}
+            #
+            def option_method(name, block=nil)
+              if block
+                self.__send__ :define_method, name, &block
+              else
+                self.__send__ :define_method, name do |*args|
+                  # 1. Component has empty @args (ie. no user supplied name or @hash value)
+                  if @args && @args.respond_to?(:to_hash) && @args.empty?
+                    @hash[self.name.to_sym].update name.to_sym => args.first
+                  # 2. Component user-supplied name or @hash value passed in @args
+                  else
+                    @hash[self.name.to_sym] = { @args => {} } unless @hash[self.name.to_sym][@args]
+                    @hash[self.name.to_sym][@args].update name.to_sym => args.first
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def initialize(*args, &block)
+          @hash    = { name => {} }
+          @args    = args.first || {}
+          @options = args.size > 1 ? args.last : {}
+          @block   = block
+        end
+
+        module ClassMethods
+
+          # Get or set the name for the DSL class
+          #
+          # @example Set the index name for the `Article` model and re-evaluate it on each call
+          #
+          #     class MyQuery
+          #       include BaseComponent
+          #       name :my_special_query
+          #     end
+          #
+          #     MyQuery.name
+          #     # => :my_special_query
+          #
+          def name(value=nil)
+            if value
+              @name = value.to_sym
+            else
+              @name ||= begin
+                value = self.to_s.split('::').last
+                value.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+                value.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+                value.tr!("-", "_")
+                value.downcase!
+                value.to_sym
+              end
+            end
+          end
+
+          # Set the name for the DSL class
+          #
+          def name=(value)
+            @name = value.to_sym
+          end
+        end
+
+        module InstanceMethods
+
+          # Return the name for instance of the DSL class
+          #
+          # @return [String]
+          #
+          def name
+            self.class.name
+          end
+
+          # Evaluates any block passed to the query
+          #
+          # @return [self]
+          #
+          def call
+            @block.arity < 1 ? self.instance_eval(&@block) : @block.call(self) if @block
+            self
+          end
+
+          # Return true when the component definition is empty
+          #
+          def empty?
+            to_hash[name].respond_to?(:empty?) && to_hash[name].empty?
+          end
+
+          # Convert the query definition to a Hash
+          #
+          # A default implementation, DSL classes can overload it.
+          #
+          # @return [Hash]
+          #
+          def to_hash(options={})
+            case
+              # 1. Create hash from the block
+              when @block
+                @hash = (@args && ! @args.empty?) ? { name => { @args => {} } } : { name => {} }
+                call
+                @hash[self.name.to_sym].update @options unless @options.empty?
+                @hash
+              # 2. Hash created with option methods
+              when @hash[self.name.to_sym] && ! @args.is_a?(Hash) && @hash[self.name.to_sym][@args]
+                @hash[self.name.to_sym].update @options unless @options.empty?
+                @hash
+              # 3. Hash passsed as @args
+              when @hash[self.name.to_sym] && @args.respond_to?(:to_hash) && ! @args.empty?
+                { name => @args.to_hash }
+              # 4. Hash already built
+              else
+                @hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/base_compound_filter_component.rb

@@ -0,0 +1,97 @@
+module Elasticsearch
+  module DSL
+    module Search
+
+      # Module containing common functionality for a "compound" (wrapping) filters, such as `and`, `or`, `not`
+      #
+      module BaseCompoundFilterComponent
+        include Enumerable
+
+        def initialize(*args, &block)
+          super
+          @value = []
+        end
+
+        def self.included(base)
+          base.__send__ :include, InstanceMethods
+          base.__send__ :include, EnumerableMethods
+          base.__send__ :include, MethodDelegation
+        end
+
+        # Common functionality for the compound filter components
+        #
+        module InstanceMethods
+          # Evaluates the block passed to initializer, ensuring it is called just once
+          #
+          # @return [self]
+          #
+          # @api private
+          #
+          def call
+            @block.arity < 1 ? self.instance_eval(&@block) : @block.call(self) if @block && ! @_block_called
+            @_block_called = true
+            self
+          end
+
+          # Convert the component to a Hash
+          #
+          # A default implementation, DSL classes can overload it.
+          #
+          # @return [Hash]
+          #
+          def to_hash(options={})
+            case
+            when @value.empty? && ! @block
+              @hash = super
+            when @block
+              call
+              @hash = { name.to_sym => @value.map { |i| i.to_hash } }
+            else
+              @hash = { name.to_sym => @value }
+            end
+            @hash
+          end
+        end
+
+        # Implements the {Enumerable} methods
+        #
+        module EnumerableMethods
+          def each(&block)
+            @value.each(&block)
+          end
+
+          def slice(*args)
+            @value.slice(*args)
+          end; alias :[] :slice
+
+          def size
+            @value.size
+          end
+
+          def <<(value)
+            @value << value
+          end
+
+          def empty?
+            @value.empty?
+          end
+        end
+
+        module MethodDelegation
+          # Looks up the corresponding class for a method being invoked, and initializes it
+          #
+          # @raise [NoMethodError] When the corresponding class cannot be found
+          #
+          def method_missing(name, *args, &block)
+            klass = Utils.__camelize(name)
+            if Filters.const_defined? klass
+              @value << Filters.const_get(klass).new(*args, &block)
+            else
+              raise NoMethodError, "undefined method '#{name}' for #{self}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/filter.rb

@@ -0,0 +1,56 @@
+module Elasticsearch
+  module DSL
+    module Search
+
+      # Contains the classes for Elasticsearch filters
+      #
+      module Filters;end
+
+      # Wraps the `filter` part of a search definition, aggregation, etc
+      #
+      # @see http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-filters.html
+      #
+      class Filter
+        def initialize(*args, &block)
+          @block = block
+        end
+
+        # Looks up the corresponding class for a method being invoked, and initializes it
+        #
+        # @raise [NoMethodError] When the corresponding class cannot be found
+        #
+        def method_missing(name, *args, &block)
+          klass = Utils.__camelize(name)
+          if Filters.const_defined? klass
+            @value = Filters.const_get(klass).new *args, &block
+          else
+            raise NoMethodError, "undefined method '#{name}' for #{self}"
+          end
+        end
+
+        # Evaluates any block passed to the query
+        #
+        # @return [self]
+        #
+        def call
+          @block.arity < 1 ? self.instance_eval(&@block) : @block.call(self) if @block
+          self
+        end
+
+        # Converts the query definition to a Hash
+        #
+        # @return [Hash]
+        #
+        def to_hash(options={})
+          call
+          if @value
+            @value.to_hash
+          else
+            {}
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/elasticsearch/dsl/search/filters/and.rb

@@ -0,0 +1,45 @@
+module Elasticsearch
+  module DSL
+    module Search
+      module Filters
+
+        # A compound filter which matches documents by an intersection of individual filters.
+        #
+        # @note Since `and` is a keyword in Ruby, use the `_and` method in DSL definitions
+        #
+        # @example Pass the filters as a Hash
+        #     search do
+        #       query do
+        #         filtered do
+        #           filter do
+        #             _and filters: [ {term: { color: 'red' }}, {term: { size:  'xxl' }} ]
+        #           end
+        #         end
+        #       end
+        #     end
+        #
+        # @example Define the filters with a block
+        #
+        #     search do
+        #       query do
+        #         filtered do
+        #           filter do
+        #             _and do
+        #               term color: 'red'
+        #               term size:  'xxl'
+        #             end
+        #           end
+        #         end
+        #       end
+        #     end
+        #
+        # @see http://elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-and-filter.html
+        #
+        class And
+          include BaseComponent
+          include BaseCompoundFilterComponent
+        end
+      end
+    end
+  end
+end