daedal 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee41dfa3c33abb94b45a246a59dd12b9ed45a278
-  data.tar.gz: 4ec21b922bb6b1e9fcd5cb94f6effad2159d8d70
+  metadata.gz: 01d15eb052c93f8a9dedb824873a533e876c5eee
+  data.tar.gz: d3408e2da2b82d8c35bf1cb07330fdb62e09c547
 SHA512:
-  metadata.gz: 0676d06f03db74a4cf9fe0fa016f0d7197d75fc1a1c2acb21780e5b22191ff9a487f9022580a412943b62f968b8d19f9264b3a3ece0cc719475e5a70a74c47d2
-  data.tar.gz: c7a4f7ece2fa6d1aebc00fdad3b095ff22b529a84aba9440124b6d5b607da38ce62c117cad8905a1b476fb8cfdee085e94dc27a3e9b86f09c446224f7279c0b8
+  metadata.gz: 1d850b9dd24946209c622306d762e8aa228994de8bdb303e19a0f572b118f42d7a6ee7df0c4ca87c17d32c512ed53f68f541e13c49bf8b28037d42072626762a
+  data.tar.gz: 3eb44d37d68e10dc6cec2c3a5a76b3cf9e146a8c612ed4628c36818aec056a45ab587f94577380a522c484bc60db3b9ad0df4c3b97a9e2bc545f92ef7e15b701

data/README.md

@@ -1,4 +1,171 @@
 Daedal
-=====================
+======
 
-Ruby classes for easier ElasticSearch query building
+This repository contains a set of Ruby classes designed to make ElasticSearch
+query creation simpler and easier to debug. The goal is to reproduce all
+components of the ElasticSearch [Query DSL](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl.html)
+to aid in the construction of complex queries. Type checking and attribute
+coercion are handled using [Virtus](https://github.com/solnic/virtus) to make
+it harder to construct invalid ElasticSearch queries before sending them to the server.
+
+The ElasticSearch Query DSL is huge! There are also a ton of different options within each
+component. My goal is to include as much of that functionality and flexibility as possible, but
+also maintain as high of test coverage as possible. That means it'll take some time for this project
+to reach full coverage of the Query DSL, so please feel free to contribute or be patient :)
+
+Installation
+------------
+
+``` terminal
+$ gem install daedal
+```
+
+or in your `Gemfile`
+
+``` ruby
+gem 'daedal'
+```
+
+Usage
+--------
+
+### ElasticSearch Query DSL
+
+Other Ruby packages for ElasticSearch allow you to create queries either as
+hashes or by constructing raw JSON:
+
+``` ruby
+match_query = {'match' => {'foo' => {'query' => 'bar'}}}
+```
+
+For more complicated queries, dealing with the resulting large nested hash can be
+frustrating. Inspired by ElasticSearch's built in 
+[Java API](http://www.elasticsearch.org/guide/en/elasticsearch/client/java-api/current/),
+Daedal contains Ruby classes designed to make query construction more Ruby-like.
+
+### Queries
+
+Queries are contained within the `Queries` module. You can construct query components like:
+
+``` ruby
+require 'daedal'
+
+# creates the basic match query
+match_query = Daedal::Queries::MatchQuery.new(field: 'foo', query: 'bar')
+```
+Each query object has `#to_json` defined for easy conversion for use with any of the Ruby
+ElasticSearch clients out there:
+``` ruby
+match_query.to_json # => "{\"match\":{\"foo\":{\"query\":\"bar\"}}}"
+```
+
+To date (12/8/2013), I have implemented the following queries:
+* [bool query](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-bool-query.html)
+* [constant score query](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-constant-score-query.html)
+* [dis max query](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-dis-max-query.html)
+* [filtered query](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-filtered-query.html)
+* [match all query](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-match-all-query.html)
+* [match query](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-match-query.html)
+* [multi match query](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-multi-match-query.html)
+
+### Filters
+
+Filters are contained within the `Filters` module. You can construct filter components
+in the same way as queries:
+
+``` ruby
+require 'daedal'
+
+term_filter = Daedal::Filters::TermFilter.new(field: 'foo', term: 'bar')
+
+term_filter.to_json # => "{\"term\":{\"foo\":\"bar\"}}"
+```
+
+To date (12/8/2013), I have implemented the following filters:
+* [term filter](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/query-dsl-term-filter.html)
+
+### Type checking and attribute coercion
+
+When creating ElasticSearch queries via nested hashes, it is all too easy to
+assign an invalid value to a specific field, which would then result in
+an error response when sending the query to the server. For instance, the query:
+
+``` ruby
+constant_score_query = {'constant_score' => {'boost' => 'foo', 'query': {'match_all': {}}}}
+```
+
+would yield a server error, since the `boost` parameter must be a number.
+
+Daedal uses [Virtus](https://github.com/solnic/virtus) to perform data-type coercions. 
+That way, invalid query parameters are surfaced at runtime, making debugging easier.
+The previous `constant_score_query` example in Daedal would raise an error:
+
+``` ruby
+match_all_query = Daedal::Queries::MatchAllQuery.new()
+constant_score_query = Daedal::Queries::ConstantScoreQuery.new(boost: 'foo', query: match_all_query)
+
+# Virtus::CoercionError: Failed to coerce "foo" into Float
+```
+
+### Creating your own queries
+
+Currently, I've only made it through a fraction of the entire Query DSL, but will be working to
+achieve complete coverage as quickly as possible. If you need to use a query that
+I haven't gotten to yet, or if you want to create your own more specialized queries within
+your own project, defining the query classes is relatively straightforward - just make
+your new class a sublass of the `Daedal::Queries::BaseQuery` or `Daedal::Filters::BaseFilter`
+classes, and define the `to_hash` method. All methods made available by including `Virtus.model` in your
+class will be available to you, as well.
+
+Example:
+``` ruby
+class MyQuery < Daedal::Queries::BaseQuery
+  
+  # define the attributes that you need in your query
+  attribute :foo, String
+  attribute :bar, String
+
+  # define the to_hash method to convert for use in ElasticSearch 
+  def to_hash
+    ...
+  end
+end
+```
+
+Contributing
+-------------
+
+The ElasticSearch Query DSL is pretty large and includes a ton of nuance. I'm starting with the
+most basic parts of the DSL (and the parts I use for work), so if you want to help out with the project
+to meet your needs please feel free to contribute! I just ask that you:
+
+* Fork the project.
+* Make your changes or additions.
+* Add tests! My goal is complete test coverage, so please take the effort to make them pretty comprehensive.
+* Send me a pull request.
+
+Feedback or suggestions are also always welcome. 
+
+License
+-------
+
+The MIT License (MIT)
+
+Copyright (c) 2013 Christopher Schuch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/daedal.gemspec

@@ -1,6 +1,8 @@
+require File.expand_path('../lib/daedal/version', __FILE__)
+
 Gem::Specification.new do |s|
   s.name        = 'daedal'
-  s.version     = '0.0.2'
+  s.version     = Daedal::VERSION
   s.date        = '2013-12-06'
   s.summary     = "ElasticSearch Query DSL Builders"
   s.description = "Classes for easier ElasticSearch query creation"
@@ -11,4 +13,6 @@ Gem::Specification.new do |s|
   s.license     = 'MIT'
   s.homepage    =
     'https://github.com/cschuch/daedal'
+
+  s.add_dependency('virtus', '~> 1.0.0')
 end

data/lib/daedal.rb

@@ -1,4 +1,5 @@
 require 'json'
+
 require 'daedal/queries'
 require 'daedal/filters'
 require 'daedal/attributes'

data/lib/daedal/attributes.rb

@@ -1,94 +1,10 @@
 require 'virtus'
-require 'daedal/queries/base_query'
-require 'daedal/filters/base_filter'
+require 'daedal/attributes/operator'
+require 'daedal/attributes/match_type'
+require 'daedal/attributes/query_array'
+require 'daedal/attributes/score_mode'
 
 module Daedal
   module Attributes
-
-    """Custom coercer for a query, allowing nil"""
-    class QueryOrNil < Virtus::Attribute
-      def coerce(value)
-        unless value.is_a? Daedal::Queries::BaseQuery or value.nil?
-          raise "Invalid query"
-        end
-        value
-      end
-    end
-
-    """Custom coercer for a filter, allowing nil"""
-    class FilterOrNil < Virtus::Attribute
-      def coerce(value)
-        unless value.is_a? Daedal::Filters::BaseFilter or value.nil?
-          raise "Invalid filter"
-        end
-        value
-      end
-    end
-
-    """Custom coercer for a query"""
-    class Query < Virtus::Attribute
-      def coerce(value)
-        unless value.is_a? Daedal::Queries::BaseQuery
-          raise "Must give a query"
-        end
-        value
-      end
-    end
-
-    """Custom coercer for a filter"""
-    class Filter < Virtus::Attribute
-      def coerce(value)
-        unless value.is_a? Daedal::Filters::BaseFilter
-          raise "Must give a filter"
-        end
-        value
-      end
-    end
-
-    """Custom coercer for an array of queries"""
-    class QueryArray < Virtus::Attribute
-      def coerce(value)
-        unless value.is_a? Array
-          value = [value]
-        end
-
-        value.each do |q|
-          unless q.is_a? Daedal::Queries::BaseQuery
-            raise "Must give an array of queries"
-          end
-        end
-
-        value
-      end
-    end
-
-    """Custom coercer for the operator attribute"""
-    class Operator < Virtus::Attribute
-      ALLOWED_MATCH_OPERATORS = [:or, :and]
-      def coerce(value)
-        unless value.nil?
-          value = value.to_sym
-          unless ALLOWED_MATCH_OPERATORS.include? value
-            raise "#{value} is not a valid operator. Allowed values are #{ALLOWED_MATCH_OPERATORS}."
-          end
-        end
-        value
-      end
-    end
-  
-    """Custom coercer for the type attribute"""
-    class MatchType < Virtus::Attribute
-      ALLOWED_MATCH_TYPES = [:phrase, :phrase_prefix]
-      def coerce(value)
-        unless value.nil?
-          value = value.to_sym
-          unless ALLOWED_MATCH_TYPES.include? value
-            raise "#{value} is not a valid type. Allowed values are #{ALLOWED_MATCH_TYPES}."
-          end
-        end
-        value
-      end
-    end
-
   end
 end

data/lib/daedal/attributes/match_type.rb

@@ -0,0 +1,17 @@
+module Daedal
+  module Attributes
+    """Custom coercer for the type attribute"""
+    class MatchType < Virtus::Attribute
+      ALLOWED_MATCH_TYPES = [:phrase, :phrase_prefix]
+      def coerce(value)
+        unless value.nil?
+          value = value.to_sym
+          unless ALLOWED_MATCH_TYPES.include? value
+            raise Virtus::CoercionError.new(value, 'Daedal::Attributes::MatchType')
+          end
+        end
+        value
+      end
+    end
+  end
+end

data/lib/daedal/attributes/operator.rb

@@ -0,0 +1,17 @@
+module Daedal
+  module Attributes
+    """Custom coercer for the operator attribute"""
+    class Operator < Virtus::Attribute
+      ALLOWED_MATCH_OPERATORS = [:or, :and]
+      def coerce(value)
+        unless value.nil?
+          value = value.to_sym
+          unless ALLOWED_MATCH_OPERATORS.include? value
+            raise Virtus::CoercionError.new(value, 'Daedal::Attributes::Operator')
+          end
+        end
+        value
+      end
+    end
+  end
+end

data/lib/daedal/attributes/query_array.rb

@@ -0,0 +1,16 @@
+module Daedal
+  module Attributes
+    """Custom attribute for an array of queries"""
+    class QueryArray < Array
+      # override the << method so that you throw
+      # an error if you don't try to append a query
+      def <<(q)
+        if q.is_a? Daedal::Queries::BaseQuery
+          super q
+        else
+          raise Virtus::CoercionError.new(q, 'Daedal::Queries::BaseQuery')
+        end
+      end
+    end
+  end
+end

data/lib/daedal/attributes/score_mode.rb

@@ -0,0 +1,17 @@
+module Daedal
+  module Attributes
+    """Custom coercer for the type attribute"""
+    class ScoreMode < Virtus::Attribute
+      ALLOWED_SCORE_MODES = [:avg, :total, :max, :none]
+      def coerce(value)
+        unless value.nil?
+          value = value.to_sym
+          unless ALLOWED_SCORE_MODES.include? value
+            raise Virtus::CoercionError.new(value, 'Daedal::Attributes::MatchType')
+          end
+        end
+        value
+      end
+    end
+  end
+end

data/lib/daedal/filters.rb

@@ -1,5 +1,6 @@
 require 'daedal/filters/base_filter'
 require 'daedal/filters/term_filter'
+require 'daedal/filters/terms_filter'
 
 module Daedal
   module Filters

data/lib/daedal/filters/term_filter.rb

@@ -3,7 +3,7 @@ require 'daedal/attributes'
 
 module Daedal
   module Filters
-    """Class for the basic match query"""
+    """Class for the basic term filter"""
     class TermFilter < BaseFilter
   
       # required attributes

data/lib/daedal/filters/terms_filter.rb

@@ -0,0 +1,18 @@
+require 'daedal/filters/base_filter'
+require 'daedal/attributes'
+
+module Daedal
+  module Filters
+    """Class for the basic term filter"""
+    class TermsFilter < BaseFilter
+  
+      # required attributes
+      attribute :field, Symbol
+      attribute :terms, Array[Symbol]
+  
+      def to_hash
+        {terms: {field => terms}}
+      end
+    end
+  end
+end

data/lib/daedal/queries.rb

@@ -6,6 +6,7 @@ require 'daedal/queries/filtered_query'
 require 'daedal/queries/match_all_query'
 require 'daedal/queries/match_query'
 require 'daedal/queries/multi_match_query'
+require 'daedal/queries/nested_query'
 
 module Daedal
   module Queries

data/lib/daedal/queries/base_query.rb

@@ -2,9 +2,18 @@ require 'virtus'
 
 module Daedal
   module Queries
+
+    """Base class for queries. All other queries
+    should inherit from this class directly in order to
+    allow for data-type coercion for compound queries
+    like the bool or dis max query"""
     class BaseQuery
+      # Virtus coercion is set to strict so that errors
+      # are returned when supplied fields cannot be properly
+      # coerced.
       include Virtus.model strict: true
 
+      # requires the subclasses to define #to_hash
       def to_json
         to_hash.to_json
       end

data/lib/daedal/queries/bool_query.rb

@@ -3,42 +3,25 @@ require 'daedal/attributes'
 
 module Daedal
   module Queries
-    """Class for the basic match query"""
+    """Class for the bool query"""
     class BoolQuery < BaseQuery
   
       # required attributes
-      attribute :should, Attributes::QueryArray, default: Array.new
-      attribute :must, Attributes::QueryArray, default: Array.new
-      attribute :must_not, Attributes::QueryArray, default: Array.new
+
+      # should, must, and must_not must be an array of queries
+      # these queries must inherit from the BaseQuery class
+      attribute :should, Attributes::QueryArray[Daedal::Queries::BaseQuery], default: Array.new
+      attribute :must, Attributes::QueryArray[Daedal::Queries::BaseQuery], default: Array.new
+      attribute :must_not, Attributes::QueryArray[Daedal::Queries::BaseQuery], default: Array.new
   
       # non required attributes
       attribute :minimum_should_match, Integer, required: false
       attribute :boost, Integer, required: false
-  
-      def verify_query(q)
-        unless q.is_a? Daedal::Queries::BaseQuery
-          raise "Must give a valid query"
-        end
-      end
-  
-      def add_should_query(q)
-        verify_query(q)
-        should << q
-      end
-  
-      def add_must_query(q)
-        verify_query(q)
-        must << q
-      end
-  
-      def add_must_not_query(q)
-        verify_query(q)
-        must_not << q
-      end
+      attribute :name, Symbol, required: false
   
       def to_hash
         result = {bool: {should: should.map {|q| q.to_hash}, must: must.map {|q| q.to_hash}, must_not: must_not.map {|q| q.to_hash}}}
-        options = {minimum_should_match: minimum_should_match, boost: boost}
+        options = {minimum_should_match: minimum_should_match, boost: boost, _name: name}
         result[:bool].merge!(options.select { |k,v| !v.nil? })
   
         result

data/lib/daedal/queries/constant_score_query.rb

@@ -1,18 +1,20 @@
 require 'daedal/queries/base_query'
+require 'daedal/filters/base_filter'
 require 'daedal/attributes'
 
 module Daedal
   module Queries
-    """Class for the basic match query"""
+    """Class for the constant score query"""
     class ConstantScoreQuery < BaseQuery
 
       # required attributes
       attribute :boost, Float
 
       # non required attributes, but one must be required of the two
-      attribute :query, Attributes::QueryOrNil
-      attribute :filter, Attributes::FilterOrNil
+      attribute :query, Daedal::Queries::BaseQuery, required: false
+      attribute :filter, Daedal::Filters::BaseFilter, required: false
 
+      # you must require *one of* query or filter in order for this to be valid
       def initialize(options={})
         super options
         if query.nil? && filter.nil?

data/lib/daedal/queries/dis_max_query.rb

@@ -4,27 +4,16 @@ require 'daedal/attributes'
 module Daedal
   module Queries
 
-    """Class for the basic match query"""
+    """Class for the dis max query"""
     class DisMaxQuery < BaseQuery
   
       # required attributes
-      attribute :queries, Attributes::QueryArray, default: Array.new
+      attribute :queries, Attributes::QueryArray[Daedal::Queries::BaseQuery], default: Array.new
   
       # non required attributes
       attribute :tie_breaker, Float, required: false
       attribute :boost, Integer, required: false
   
-      def verify_query(q)
-        unless q.is_a? Daedal::Queries::BaseQuery
-          raise "Must give a valid query"
-        end
-      end
-  
-      def add_query(q)
-        verify_query(q)
-        queries << q
-      end
-  
       def to_hash
         result = {dis_max: {queries: queries.map {|q| q.to_hash }}}
         options = {tie_breaker: tie_breaker, boost: boost}

data/lib/daedal/queries/filtered_query.rb

@@ -5,12 +5,12 @@ require 'daedal/attributes'
 
 module Daedal
   module Queries
-    """Class for the basic match query"""
+    """Class for the filtered query"""
     class FilteredQuery < BaseQuery
   
       # required attributes
-      attribute :query, Attributes::Query, default: Daedal::Queries::MatchAllQuery.new
-      attribute :filter, Attributes::Filter, default: Daedal::Filters::BaseFilter.new
+      attribute :query, Daedal::Queries::BaseQuery, default: Daedal::Queries::MatchAllQuery.new
+      attribute :filter, Daedal::Filters::BaseFilter, default: Daedal::Filters::BaseFilter.new
   
       def to_hash
         {filtered: {query: query.to_hash, filter: filter.to_hash}}

data/lib/daedal/queries/match_all_query.rb

@@ -2,7 +2,7 @@ require 'daedal/queries/base_query'
 
 module Daedal
   module Queries
-    """Class for the basic match query"""
+    """Class for the match all query"""
     class MatchAllQuery < BaseQuery
       def to_hash
         {match_all: {}}

data/lib/daedal/queries/match_query.rb

@@ -4,7 +4,7 @@ require 'daedal/attributes'
 module Daedal
   module Queries
 
-    """Class for the basic match query"""
+    """Class for the match query"""
     class MatchQuery < BaseQuery
   
       # required attributes

data/lib/daedal/queries/multi_match_query.rb

@@ -4,7 +4,7 @@ require 'daedal/attributes'
 module Daedal
   module Queries
 
-    """Class for the multi_match query"""
+    """Class for the multi match query"""
     class MultiMatchQuery < BaseQuery
   
       # required attributes
@@ -22,6 +22,7 @@ module Daedal
       attribute :boost, Integer, required: false
       attribute :fuzziness, Float, required: false
   
+      # Fields cannot be an empty array... should eventually refactor this kind of thing out of initialize
       def initialize(options={})
         super options
   

data/lib/daedal/queries/nested_query.rb

@@ -0,0 +1,26 @@
+require 'daedal/queries/base_query'
+require 'daedal/attributes'
+
+module Daedal
+  module Queries
+    """Class for the bool query"""
+    class NestedQuery < BaseQuery
+  
+      # required attributes
+      attribute :path, Symbol
+      attribute :query, Daedal::Queries::BaseQuery
+  
+      # non required attributes
+      attribute :score_mode, Attributes::ScoreMode, required: false
+  
+      def to_hash
+        result = {nested: {path: path, query: query.to_hash}}
+        unless score_mode.nil?
+          result[:nested][:score_mode] = score_mode
+        end
+
+        result
+      end
+    end
+  end
+end

data/spec/unit/daedal/filters/terms_filter_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'daedal/filters'
+
+describe Daedal::Filters::TermsFilter do
+
+  subject do
+    Daedal::Filters::TermsFilter
+  end
+
+  let(:field) do
+    :foo
+  end
+
+  let(:terms) do
+    [:foo, :bar]
+  end
+
+  let(:hash_filter) do
+    {terms: {field => terms}}
+  end
+
+  context 'without a field or a list of terms specified' do
+    it 'will raise an error' do
+      expect {subject.new}.to raise_error
+    end
+  end
+
+  context 'without a field specified' do
+    it 'will raise an error' do
+      expect {subject.new(terms: terms)}.to raise_error
+    end
+  end
+
+  context 'with a field and a list of terms specified' do
+    let(:filter) do
+      subject.new(field: field, terms: terms.map {|t| t.to_s})
+    end
+    it 'will populate the field and term attributes appropriately' do
+      expect(filter.field).to eq field
+      expect(filter.terms).to eq terms
+    end
+    it 'will have the correct hash representation' do
+      expect(filter.to_hash).to eq hash_filter
+    end
+    it 'will have the correct json representation' do
+      expect(filter.to_json).to eq hash_filter.to_json
+    end
+  end
+end

data/spec/unit/daedal/queries/bool_query_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'daedal/queries'
+require 'debugger'
 
 describe Daedal::Queries::BoolQuery do
 
@@ -136,9 +137,9 @@ describe Daedal::Queries::BoolQuery do
       match_query.new(field: :a, query: :b)
     end
 
-    context 'with the #add_should_query method' do
+    context 'with the should.<< method' do
       before do
-        query.add_should_query mq
+        query.should << mq
       end
       it 'will add a should query' do
         expect(query.should).to eq [mq]
@@ -146,7 +147,7 @@ describe Daedal::Queries::BoolQuery do
 
       context 'twice' do
         before do
-          query.add_should_query mq
+          query.should << mq
         end
         it 'will append the second query' do
           expect(query.should).to eq [mq, mq]
@@ -155,14 +156,14 @@ describe Daedal::Queries::BoolQuery do
 
       context 'with a non-valid query' do
         it 'will raise an error' do
-          expect{query.add_should_query :foo}.to raise_error
+          expect{query.should << :foo}.to raise_error
         end
       end
     end
 
-    context 'with the #add_must_query method' do
+    context 'with the must.<< method' do
       before do
-        query.add_must_query mq
+        query.must << mq
       end
 
       it 'will add a should query' do
@@ -171,7 +172,7 @@ describe Daedal::Queries::BoolQuery do
 
       context 'twice' do
         before do
-          query.add_must_query mq
+          query.must << mq
         end
         it 'will append the second query' do
           expect(query.must).to eq [mq, mq]
@@ -180,15 +181,15 @@ describe Daedal::Queries::BoolQuery do
 
       context 'with a non-valid query' do
         it 'will raise an error' do
-          expect {query.add_must_query :foo}.to raise_error
+          expect {query.must << :foo}.to raise_error
         end
       end
 
     end
 
-    context 'with the #add_must_not_query method' do
+    context 'with the must_not.<< method' do
       before do
-        query.add_must_not_query mq
+        query.must_not << mq
       end
 
       it 'will add a must_not query' do
@@ -197,7 +198,7 @@ describe Daedal::Queries::BoolQuery do
 
       context 'twice' do
         before do
-          query.add_must_not_query mq
+          query.must_not << mq
         end
         it 'will append the second query' do
           expect(query.must_not).to eq [mq, mq]
@@ -206,7 +207,7 @@ describe Daedal::Queries::BoolQuery do
 
       context 'with a non-valid query' do
         it 'will raise an error' do
-          expect {query.add_must_not_query :foo}.to raise_error
+          expect {query.must_not << :foo}.to raise_error
         end
       end
     end

data/spec/unit/daedal/queries/constant_score_query_spec.rb

@@ -36,6 +36,18 @@ describe Daedal::Queries::ConstantScoreQuery do
     end
   end
 
+  context 'with a boost but an invalid query specified' do
+    it 'will raise an error' do
+      expect {subject.new(boost: 5, query: :foo)}.to raise_error
+    end
+  end
+
+  context 'with a boost but an invalid filter specified' do
+    it 'will raise an error' do
+      expect {subject.new(boost: 5, filter: :foo)}.to raise_error
+    end
+  end
+
   context 'with a query and a boost specified' do
     let(:query) do
       subject.new(query: match_query, boost: 5)

data/spec/unit/daedal/queries/dis_max_query_spec.rb

@@ -124,9 +124,9 @@ describe Daedal::Queries::DisMaxQuery do
       match_query.new(field: :a, query: :b)
     end
 
-    context 'with the #add_query method' do
+    context 'with the queries.<< method' do
       before do
-        query.add_query mq
+        query.queries << mq
       end
       it 'will add a query' do
         expect(query.queries).to eq [mq]
@@ -134,7 +134,7 @@ describe Daedal::Queries::DisMaxQuery do
 
       context 'twice' do
         before do
-          query.add_query mq
+          query.queries << mq
         end
         it 'will append the second query' do
           expect(query.queries).to eq [mq, mq]
@@ -143,7 +143,7 @@ describe Daedal::Queries::DisMaxQuery do
 
       context 'with a non-valid query' do
         it 'will raise an error' do
-          expect{query.add_query :foo}.to raise_error
+          expect{query.queries << :foo}.to raise_error
         end
       end
     end

data/spec/unit/daedal/queries/filtered_query_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'daedal/queries'
+require 'daedal/filters'
 
 describe Daedal::Queries::FilteredQuery do
 
@@ -40,6 +41,18 @@ describe Daedal::Queries::FilteredQuery do
     end
   end
 
+  context 'with an invalid query specified' do
+    it 'will raise an error' do
+      expect{subject.new(query: :foo)}.to raise_error
+    end
+  end
+
+  context 'with an invalid filter specified' do
+    it 'will raise an error' do
+      expect{subject.new(filter: :foo)}.to raise_error
+    end
+  end
+
   context 'with a query and a filter specified' do
     let(:query) do
       subject.new(query: match_query, filter: term_filter)

data/spec/unit/daedal/queries/nested_query_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'daedal/queries'
+require 'daedal/filters'
+
+describe Daedal::Queries::NestedQuery do
+
+  subject do
+    Daedal::Queries::NestedQuery
+  end
+
+  let(:match_all_query) do
+    Daedal::Queries::MatchAllQuery.new
+  end
+
+  context 'with no path specified' do
+    it 'will raise an error' do
+      expect{subject.new(query: match_all_query)}.to raise_error
+    end
+  end
+
+  context 'with no query specified' do
+    it 'will raise an error' do
+      expect{subject.new(path: 'foo')}.to raise_error
+    end
+  end
+
+  context 'with an invalid query specified' do
+    it 'will raise an error' do
+      expect{subject.new(query: :foo)}.to raise_error
+    end
+  end
+
+  context 'with a query and a path specified' do
+    let(:query) do
+      subject.new query: match_all_query, path: :foo
+    end
+    let(:hash_query) do
+      {nested: {path: :foo, query: match_all_query.to_hash}}
+    end
+
+    it 'will create a nested query with the appropriate fields' do
+      expect(query.query).to eq match_all_query
+      expect(query.path).to eq :foo
+    end
+
+    it 'will have the correct hash representation' do
+      expect(query.to_hash).to eq hash_query
+    end
+
+    it 'will have the correct json representation' do
+      expect(query.to_json).to eq hash_query.to_json
+    end
+  end
+
+  context 'with score_mode specified' do
+    let(:query) do
+      subject.new query: match_all_query, path: :foo, score_mode: :avg
+    end
+    let(:hash_query) do
+      {nested: {path: :foo, query: match_all_query.to_hash, score_mode: :avg}}
+    end
+
+    it 'will create a nested query with the appropriate fields' do
+      expect(query.query).to eq match_all_query
+      expect(query.path).to eq :foo
+      expect(query.score_mode).to eq :avg
+    end
+
+    it 'will have the correct hash representation' do
+      expect(query.to_hash).to eq hash_query
+    end
+    it 'will have the correct json representation' do
+      expect(query.to_json).to eq hash_query.to_json
+    end
+  end
+
+  context 'with an invalid score_mode specified' do
+    it 'will raise an error' do
+      expect{subject.new(query: match_all_query, path: :foo, score_mode: 'foo')}.to raise_error
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daedal
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Christopher Schuch
@@ -9,7 +9,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2013-12-06 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 description: Classes for easier ElasticSearch query creation
 email: cas13091@gmail.com
 executables: []
@@ -26,9 +40,14 @@ files:
 - daedal.gemspec
 - lib/daedal.rb
 - lib/daedal/attributes.rb
+- lib/daedal/attributes/match_type.rb
+- lib/daedal/attributes/operator.rb
+- lib/daedal/attributes/query_array.rb
+- lib/daedal/attributes/score_mode.rb
 - lib/daedal/filters.rb
 - lib/daedal/filters/base_filter.rb
 - lib/daedal/filters/term_filter.rb
+- lib/daedal/filters/terms_filter.rb
 - lib/daedal/queries.rb
 - lib/daedal/queries/base_query.rb
 - lib/daedal/queries/bool_query.rb
@@ -38,8 +57,10 @@ files:
 - lib/daedal/queries/match_all_query.rb
 - lib/daedal/queries/match_query.rb
 - lib/daedal/queries/multi_match_query.rb
+- lib/daedal/queries/nested_query.rb
 - spec/spec_helper.rb
 - spec/unit/daedal/filters/term_filter_spec.rb
+- spec/unit/daedal/filters/terms_filter_spec.rb
 - spec/unit/daedal/queries/bool_query_spec.rb
 - spec/unit/daedal/queries/constant_score_query_spec.rb
 - spec/unit/daedal/queries/dis_max_query_spec.rb
@@ -47,6 +68,7 @@ files:
 - spec/unit/daedal/queries/match_all_query_spec.rb
 - spec/unit/daedal/queries/match_query_spec.rb
 - spec/unit/daedal/queries/multi_match_query_spec.rb
+- spec/unit/daedal/queries/nested_query_spec.rb
 homepage: https://github.com/cschuch/daedal
 licenses:
 - MIT