daedal 0.0.4 → 0.0.5

data/lib/daedal/queries/fuzzy_query.rb

@@ -0,0 +1,24 @@
+module Daedal
+  module Queries
+    """Class for the fuzzy query"""
+    class FuzzyQuery < Query
+
+      # required attributes
+      attribute :field,           Daedal::Attributes::Field
+      attribute :query,           Daedal::Attributes::QueryValue
+
+      # non required attributes
+      attribute :boost,           Daedal::Attributes::Boost,      required: false
+      attribute :min_similarity,  Daedal::Attributes::QueryValue, required: false
+      attribute :prefix_length,   Integer,                        required: false
+  
+      def to_hash
+        result = {fuzzy: {field => {value: query}}}
+        options = {boost: boost, min_similarity: min_similarity, prefix_length: prefix_length}.select {|k,v| !v.nil?}
+        result[:fuzzy][field].merge!(options)
+
+        result
+      end
+    end
+  end
+end

data/lib/daedal/queries/match_all_query.rb

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

data/lib/daedal/queries/match_query.rb

@@ -1,25 +1,21 @@
-require 'daedal/queries/base_query'
-require 'daedal/attributes'
-
 module Daedal
   module Queries
-
     """Class for the match query"""
-    class MatchQuery < BaseQuery
+    class MatchQuery < Query
   
       # required attributes
-      attribute :field, Symbol
-      attribute :query, Symbol
+      attribute :field,                 Daedal::Attributes::Field
+      attribute :query,                 Daedal::Attributes::QueryValue
   
       # non required attributes
-      attribute :operator, Attributes::Operator, required: false
-      attribute :minimum_should_match, Integer, required: false
-      attribute :cutoff_frequency, Float, required: false
-      attribute :type, Attributes::MatchType, required: false
-      attribute :analyzer, Symbol, required: false
-      attribute :boost, Integer, required: false
-      attribute :fuzziness, Float, required: false
-      attribute :slop, Integer, required: false
+      attribute :operator,              Daedal::Attributes::Operator,   required: false
+      attribute :minimum_should_match,  Integer,                        required: false
+      attribute :cutoff_frequency,      Float,                          required: false
+      attribute :type,                  Daedal::Attributes::MatchType,  required: false
+      attribute :analyzer,              Symbol,                         required: false
+      attribute :boost,                 Daedal::Attributes::Boost,      required: false
+      attribute :fuzziness,             Float,                          required: false
+      attribute :slop,                  Integer,                        required: false
   
       def to_hash
   

data/lib/daedal/queries/multi_match_query.rb

@@ -1,26 +1,22 @@
-require 'daedal/queries/base_query'
-require 'daedal/attributes'
-
 module Daedal
   module Queries
-
     """Class for the multi match query"""
-    class MultiMatchQuery < BaseQuery
+    class MultiMatchQuery < Query
   
       # required attributes
-      attribute :query, Symbol
-      attribute :fields, Array[Symbol]
+      attribute :query,                 Daedal::Attributes::QueryValue
+      attribute :fields,                Array[Daedal::Attributes::Field]
   
       # non required attributes
-      attribute :use_dis_max, Boolean, default: true
-      attribute :tie_breaker, Float, default: 0.0
-      attribute :operator, Attributes::Operator, required: false
-      attribute :minimum_should_match, Integer, required: false
-      attribute :cutoff_frequency, Float, required: false
-      attribute :type, Attributes::MatchType, required: false
-      attribute :analyzer, Symbol, required: false
-      attribute :boost, Integer, required: false
-      attribute :fuzziness, Float, required: false
+      attribute :use_dis_max,           Boolean,                        required: false
+      attribute :tie_breaker,           Float,                          required: false
+      attribute :operator,              Daedal::Attributes::Operator,   required: false
+      attribute :minimum_should_match,  Integer,                        required: false
+      attribute :cutoff_frequency,      Float,                          required: false
+      attribute :type,                  Daedal::Attributes::MatchType,  required: false
+      attribute :analyzer,              Symbol,                         required: false
+      attribute :boost,                 Daedal::Attributes::Boost,      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={})

data/lib/daedal/queries/nested_query.rb

@@ -1,23 +1,20 @@
-require 'daedal/queries/base_query'
-require 'daedal/attributes'
-
 module Daedal
   module Queries
     """Class for the bool query"""
-    class NestedQuery < BaseQuery
+    class NestedQuery < Query
   
       # required attributes
-      attribute :path, Symbol
-      attribute :query, Attributes::Query
+      attribute :path,        Daedal::Attributes::Field
+      attribute :query,       Daedal::Attributes::Query
   
       # non required attributes
-      attribute :score_mode, Attributes::ScoreMode, required: false
-      attribute :name, Symbol, required: false
+      attribute :score_mode,  Daedal::Attributes::ScoreMode,  required: false
+      attribute :name,        Symbol,                         required: false
   
       def to_hash
         result = {nested: {path: path, query: query.to_hash}}
-        options = {score_mode: score_mode, _name: name}
-        result[:nested].merge!(options.select { |k,v| !v.nil? })
+        options = {score_mode: score_mode, _name: name}.select { |k,v| !v.nil? }
+        result[:nested].merge! options
 
         result
       end

data/lib/daedal/queries/prefix_query.rb

@@ -1,22 +1,20 @@
-require 'daedal/queries/base_query'
-require 'daedal/attributes'
-
 module Daedal
   module Queries
     """Class for the prefix query"""
-    class PrefixQuery < BaseQuery
+    class PrefixQuery < Query
   
       # required attributes
-      attribute :field, Symbol
-      attribute :query, Attributes::LowerCaseString
+      attribute :field,     Daedal::Attributes::Field
+      attribute :query,     Daedal::Attributes::LowerCaseString
 
       # non required attributes
-      attribute :boost, Float, required: false
+      attribute :boost,     Daedal::Attributes::Boost, required: false
   
       def to_hash
         result = {prefix: {field => query}}
-        options = {boost: boost}
-        result[:prefix].merge!(options.select { |k,v| !v.nil? })
+        unless boost.nil?
+          result[:prefix][:boost] = boost
+        end
 
         result
       end

data/lib/daedal/queries/{base_query.rb → query.rb}

@@ -1,13 +1,10 @@
-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
+    class Query
       # Virtus coercion is set to strict so that errors
       # are returned when supplied fields cannot be properly
       # coerced.

data/lib/daedal/queries/query_string_query.rb

@@ -0,0 +1,32 @@
+module Daedal
+  module Queries
+    """Class for the bool query"""
+    class QueryStringQuery < Query
+  
+      # required attributes
+      attribute :query,                         String
+
+      # non required attributes
+      attribute :default_field,                 Daedal::Attributes::Field, required: false
+      attribute :fields,                        Array[Daedal::Attributes::Field], required: false
+      attribute :default_operator,              String, required: false
+      attribute :analyzer,                      Symbol, required: false
+      attribute :allow_leading_wildcard,        Boolean, required: false
+      attribute :lowercase_expanded_terms,      Boolean, required: false
+      attribute :enable_position_increments,    Boolean, required: false
+      attribute :fuzzy_max_expansions,          Integer, required: false
+      attribute :fuzzy_min_sim,                 Float, required: false
+      attribute :fuzzy_prefix_length,           Integer, required: false
+      attribute :phrase_slop,                   Integer, required: false
+      attribute :boost,                         Daedal::Attributes::Boost, required: false
+      attribute :analyze_wildcard,              Boolean, required: false
+      attribute :auto_generate_phrase_queries,  Boolean, required: false
+      attribute :minimum_should_match,          Integer, required: false
+      attribute :lenient,                       Boolean, required: false
+  
+      def to_hash
+        {query_string: attributes.select {|k,v| (k == :fields and !v.empty?) or (k != :fields and !v.nil?)}}
+      end
+    end
+  end
+end

data/lib/daedal/version.rb

@@ -1,3 +1,3 @@
 module Daedal
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/spec/spec_helper.rb

@@ -1,5 +1,5 @@
-require 'require_all'
-require 'json'
+require 'coveralls'
+Coveralls.wear!
 
 def append_load_path(*paths)
   full_path = File.join([File.dirname(__FILE__), ".."] << paths)
@@ -9,6 +9,8 @@ end
 append_load_path('')
 append_load_path('lib')
 
+require 'daedal'
+
 RSpec.configure do |config|
   config.expect_with :rspec do |c|
     c.syntax = :expect

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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'daedal/filters'
 
 describe Daedal::Filters::AndFilter do
 

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

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Daedal::Filters::BoolFilter do
+
+  subject do
+    Daedal::Filters::BoolFilter
+  end
+
+  let(:term_filter) do
+    Daedal::Filters::TermFilter.new field: :foo, term: :bar
+  end
+
+  context 'without an initial array of filters' do
+    let(:filter) do
+      subject.new
+    end
+    let(:hash_filter) do
+      {bool: {should: [], must: [], must_not: []}}
+    end
+    it 'will set must should and must_not to empty arrays' do
+      expect(filter.must).to eq []
+      expect(filter.should).to eq []
+      expect(filter.must_not).to eq []
+    end
+    it 'will have the correct hash and json representations' do
+      expect(filter.to_hash).to eq hash_filter
+      expect(filter.to_json).to eq hash_filter.to_json
+    end
+  end
+
+  context 'with initial arrays of filters specified' do
+    let(:filter) do
+      subject.new should: [term_filter], must: [term_filter, term_filter], must_not: [term_filter, term_filter, term_filter]
+    end
+    let(:hash_filter) do
+      {bool: {should: [term_filter.to_hash], must: [term_filter.to_hash, term_filter.to_hash], must_not: [term_filter.to_hash, term_filter.to_hash, term_filter.to_hash]}}
+    end
+
+    it 'will have the correct filter array set' do
+      expect(filter.should).to eq [term_filter]
+      expect(filter.must).to eq [term_filter, term_filter]
+      expect(filter.must_not).to eq [term_filter, term_filter, term_filter]
+    end
+    it 'will have the correct hash and json representations' do
+      expect(filter.to_hash).to eq hash_filter
+      expect(filter.to_json).to eq hash_filter.to_json
+    end
+  end
+
+  context 'when adding more filters' do
+    let(:filter) do
+      subject.new
+    end
+
+    before do
+      filter.should << term_filter
+      filter.must << term_filter
+      filter.must << term_filter
+      filter.must_not << term_filter
+      filter.must_not << term_filter
+      filter.must_not << term_filter
+    end
+
+    it 'will append the filters to their arrays' do
+      expect(filter.should).to eq [term_filter]
+      expect(filter.must).to eq [term_filter, term_filter]
+      expect(filter.must_not).to eq [term_filter, term_filter, term_filter]
+    end
+  end
+
+  context 'with non filters during initialization' do
+    it 'will raise an error' do
+      expect{subject.new should: [:foo]}.to raise_error(Virtus::CoercionError)
+      expect{subject.new must: [:foo]}.to raise_error(Virtus::CoercionError)
+      expect{subject.new must_not: [:foo]}.to raise_error(Virtus::CoercionError)
+    end
+  end
+
+  context 'when trying to add a non filter' do
+    let(:filter) do
+      subject.new
+    end
+    it 'will raise an error' do
+      expect{filter.should << :foo}.to raise_error(Virtus::CoercionError)
+      expect{filter.must << :foo}.to raise_error(Virtus::CoercionError)
+      expect{filter.must_not << :foo}.to raise_error(Virtus::CoercionError)
+    end
+  end
+end

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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'daedal/filters'
 
 describe Daedal::Filters::GeoDistanceFilter do
 

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

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Daedal::Filters::OrFilter do
+
+  subject do
+    Daedal::Filters::OrFilter
+  end
+
+  let(:term_filter) do
+    Daedal::Filters::TermFilter.new field: :foo, term: :bar
+  end
+
+  context 'without an initial array of filters' do
+    let(:filter) do
+      subject.new
+    end
+    let(:hash_filter) do
+      nil
+    end
+    it 'will set must should and must_not to empty arrays' do
+      expect(filter.filters).to eq []
+    end
+    it 'will have the correct hash and json representations' do
+      expect(filter.to_hash).to eq hash_filter
+      expect(filter.to_json).to eq hash_filter.to_json
+    end
+  end
+
+  context 'with initial array of filters specified' do
+    let(:filter) do
+      subject.new filters: [term_filter]
+    end
+    let(:hash_filter) do
+      {:or => [term_filter.to_hash]}
+    end
+
+    it 'will have the correct filter array set' do
+      expect(filter.filters).to eq [term_filter]
+    end
+    it 'will have the correct hash and json representations' do
+      expect(filter.to_hash).to eq hash_filter
+      expect(filter.to_json).to eq hash_filter.to_json
+    end
+  end
+
+  context 'when adding more filters' do
+    let(:filter) do
+      subject.new
+    end
+
+    before do
+      filter.filters << term_filter
+    end
+
+    it 'will append the filters to their arrays' do
+      expect(filter.filters).to eq [term_filter]
+    end
+  end
+
+  context 'with non filters during initialization' do
+    it 'will raise an error' do
+      expect{subject.new filters: [:foo]}.to raise_error(Virtus::CoercionError)
+    end
+  end
+
+  context 'when trying to add a non filter' do
+    let(:filter) do
+      subject.new
+    end
+    it 'will raise an error' do
+      expect{filter.filters << :foo}.to raise_error(Virtus::CoercionError)
+    end
+  end
+end

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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'daedal/filters'
 
 describe Daedal::Filters::RangeFilter do
 

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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'daedal/filters'
 
 describe Daedal::Filters::TermFilter do
 

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

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'daedal/filters'
 
 describe Daedal::Filters::TermsFilter do
 
@@ -35,9 +34,12 @@ describe Daedal::Filters::TermsFilter do
     let(:filter) do
       subject.new(field: field, terms: terms.map {|t| t.to_s})
     end
+    let(:hash_filter) do
+      {terms: {field => 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
+      expect(filter.terms).to eq terms.map {|t| t.to_s}
     end
     it 'will have the correct hash representation' do
       expect(filter.to_hash).to eq hash_filter