daedal 0.0.2

data/lib/daedal/queries/filtered_query.rb

@@ -0,0 +1,20 @@
+require 'daedal/queries/match_all_query'
+require 'daedal/filters/base_filter'
+require 'daedal/queries/base_query'
+require 'daedal/attributes'
+
+module Daedal
+  module Queries
+    """Class for the basic match query"""
+    class FilteredQuery < BaseQuery
+  
+      # required attributes
+      attribute :query, Attributes::Query, default: Daedal::Queries::MatchAllQuery.new
+      attribute :filter, Attributes::Filter, default: Daedal::Filters::BaseFilter.new
+  
+      def to_hash
+        {filtered: {query: query.to_hash, filter: filter.to_hash}}
+      end
+    end
+  end
+end

data/lib/daedal/queries/match_all_query.rb

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

data/lib/daedal/queries/match_query.rb

@@ -0,0 +1,33 @@
+require 'daedal/queries/base_query'
+require 'daedal/attributes'
+
+module Daedal
+  module Queries
+
+    """Class for the basic match query"""
+    class MatchQuery < BaseQuery
+  
+      # required attributes
+      attribute :field, Symbol
+      attribute :query, Symbol
+  
+      # 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
+  
+      def to_hash
+  
+        result = {match: {field => {query: query}}}
+        options = {minimum_should_match: minimum_should_match, cutoff_frequency: cutoff_frequency, type: type, analyzer: analyzer, boost: boost, fuzziness: fuzziness, operator: operator}
+        result[:match][field].merge! options.select {|k,v| !v.nil?}
+  
+        result
+      end
+    end
+  end
+end

data/lib/daedal/queries/multi_match_query.rb

@@ -0,0 +1,43 @@
+require 'daedal/queries/base_query'
+require 'daedal/attributes'
+
+module Daedal
+  module Queries
+
+    """Class for the multi_match query"""
+    class MultiMatchQuery < BaseQuery
+  
+      # required attributes
+      attribute :query, Symbol
+      attribute :fields, Array[Symbol]
+  
+      # 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
+  
+      def initialize(options={})
+        super options
+  
+        if fields.empty?
+          raise "Must give at least one field to match on"
+        end
+      end
+  
+      def to_hash
+        result = {multi_match: {query: query, fields: fields}}
+        options = {minimum_should_match: minimum_should_match, cutoff_frequency: cutoff_frequency, type: type, analyzer: analyzer, boost: boost, fuzziness: fuzziness, operator: operator}
+  
+        result[:multi_match].merge!(options.select { |k,v| !v.nil? })
+  
+        result
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'require_all'
+require 'json'
+
+def append_load_path(*paths)
+  full_path = File.join([File.dirname(__FILE__), ".."] << paths)
+  $: << File.expand_path(full_path)
+end
+
+append_load_path('')
+append_load_path('lib')
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'daedal/filters'
+
+describe Daedal::Filters::TermFilter do
+
+  subject do
+    Daedal::Filters::TermFilter
+  end
+
+  let(:field) do
+    :foo
+  end
+
+  let(:term) do
+    :bar
+  end
+
+  let(:hash_filter) do
+    {term: {field => term}}
+  end
+
+  context 'without a field or a term 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(term: term)}.to raise_error
+    end
+  end
+
+  context 'without a term specified' do
+    it 'will raise an error' do
+      expect {subject.new(field: field)}.to raise_error
+    end
+  end
+
+  context 'with a field and a term specified' do
+    let(:filter) do
+      subject.new(field: field, term: term)
+    end
+    it 'will populate the field and term attributes appropriately' do
+      expect(filter.field).to eq field
+      expect(filter.term).to eq term
+    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

@@ -0,0 +1,214 @@
+require 'spec_helper'
+require 'daedal/queries'
+
+describe Daedal::Queries::BoolQuery do
+
+  subject do
+    Daedal::Queries::BoolQuery
+  end
+
+  let(:match_query) do
+    Daedal::Queries::MatchQuery
+  end
+
+  let(:hash_query) do
+    {bool: {should: [], must: [], must_not: []}}
+  end
+
+  context 'with no initial queries specified' do
+    let(:query) do
+      subject.new
+    end
+
+    it 'will give an empty bool query' do
+      expect(query.should).to eq Array.new
+      expect(query.must).to eq Array.new
+      expect(query.must_not).to eq Array.new
+    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
+
+    context 'with a minimum should match specified' do
+      before do
+        hash_query[:bool][:minimum_should_match] = 2
+      end
+      let(:query_with_min) do
+        subject.new(minimum_should_match: 2)
+      end
+      it 'will set the minimum_should_match parameter' do
+        expect(query_with_min.minimum_should_match).to eq 2
+      end
+      it 'will have the correct hash representation' do
+        expect(query_with_min.to_hash).to eq hash_query
+      end
+      it 'will have the correct json representation' do
+        expect(query_with_min.to_json).to eq hash_query.to_json
+      end
+    end
+
+    context 'with a boost specified' do
+      before do
+        hash_query[:bool][:boost] = 2
+      end
+      let(:query_with_boost) do
+        subject.new(boost: 2)
+      end
+      it 'will set the boost parameter' do
+        expect(query_with_boost.boost).to eq 2
+      end
+      it 'will have the correct hash representation' do
+        expect(query_with_boost.to_hash).to eq hash_query
+      end
+      it 'will have the correct json representation' do
+        expect(query_with_boost.to_json).to eq hash_query.to_json
+      end
+    end
+  end
+
+  context 'with initial arrays of queries specified' do
+
+    let(:should) do
+      [match_query.new(field: :a, query: :b), match_query.new(field: :c, query: :d)]
+    end
+    let(:must) do
+      [match_query.new(field: :e, query: :f), match_query.new(field: :g, query: :h)]
+    end
+    let(:must_not) do
+      [match_query.new(field: :i, query: :j), match_query.new(field: :k, query: :l)]
+    end
+
+    let(:query) do
+      subject.new(should: should, must: must, must_not: must_not)
+    end
+
+    before do
+      hash_query[:bool][:should] = should.map {|q| q.to_hash}
+      hash_query[:bool][:must] = must.map {|q| q.to_hash}
+      hash_query[:bool][:must_not] = must_not.map {|q| q.to_hash}
+    end
+
+    it 'will create a bool query with the appropriate initial arrays of queries' do
+      expect(query.should).to eq should
+      expect(query.must).to eq must
+      expect(query.must_not).to eq must_not
+    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 initial array of non queries specified' do
+    it 'will raise an error' do
+      expect {subject.new(should: [:foo])}.to raise_error
+    end
+  end
+
+  context 'with a query (not in an array) specified' do
+    let(:mq) do
+      match_query.new(field: :a, query: :b)
+    end
+
+    let(:query) do
+      subject.new(should: mq)
+    end
+
+    it 'will convert the input into an array of the single query' do
+      expect(query.should).to eq([mq])
+    end
+  end
+
+  context 'when adding more queries' do
+    let(:query) do
+      subject.new
+    end
+    let(:mq) do
+      match_query.new(field: :a, query: :b)
+    end
+
+    context 'with the #add_should_query method' do
+      before do
+        query.add_should_query mq
+      end
+      it 'will add a should query' do
+        expect(query.should).to eq [mq]
+      end
+
+      context 'twice' do
+        before do
+          query.add_should_query mq
+        end
+        it 'will append the second query' do
+          expect(query.should).to eq [mq, mq]
+        end
+      end
+
+      context 'with a non-valid query' do
+        it 'will raise an error' do
+          expect{query.add_should_query :foo}.to raise_error
+        end
+      end
+    end
+
+    context 'with the #add_must_query method' do
+      before do
+        query.add_must_query mq
+      end
+
+      it 'will add a should query' do
+        expect(query.must).to eq [mq]
+      end
+
+      context 'twice' do
+        before do
+          query.add_must_query mq
+        end
+        it 'will append the second query' do
+          expect(query.must).to eq [mq, mq]
+        end
+      end
+
+      context 'with a non-valid query' do
+        it 'will raise an error' do
+          expect {query.add_must_query :foo}.to raise_error
+        end
+      end
+
+    end
+
+    context 'with the #add_must_not_query method' do
+      before do
+        query.add_must_not_query mq
+      end
+
+      it 'will add a must_not query' do
+        expect(query.must_not).to eq [mq]
+      end
+
+      context 'twice' do
+        before do
+          query.add_must_not_query mq
+        end
+        it 'will append the second query' do
+          expect(query.must_not).to eq [mq, mq]
+        end
+      end
+
+      context 'with a non-valid query' do
+        it 'will raise an error' do
+          expect {query.add_must_not_query :foo}.to raise_error
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'daedal/queries'
+require 'daedal/filters'
+
+describe Daedal::Queries::ConstantScoreQuery do
+
+  subject do
+    Daedal::Queries::ConstantScoreQuery
+  end
+
+  let(:match_query) do
+    Daedal::Queries::MatchQuery.new(field: :foo, query: :bar)
+  end
+
+  let(:term_filter) do
+    Daedal::Filters::TermFilter.new(field: :foo, term: :bar)
+  end
+
+  let(:hash_query) do
+    {constant_score: { boost: 5.0, query: match_query.to_hash}}
+  end
+
+  let(:hash_filter) do
+    {constant_score: { boost: 5.0, filter: term_filter.to_hash}}
+  end
+
+  context 'without a query or a filter specified' do
+    it 'will raise an error' do
+      expect{subject.new(boost: 5)}.to raise_error
+    end
+  end
+
+  context 'without a boost specified' do
+    it 'will raise an error' do
+      expect{subject.new(query: match_query)}.to raise_error
+    end
+  end
+
+  context 'with a query and a boost specified' do
+    let(:query) do
+      subject.new(query: match_query, boost: 5)
+    end
+
+    it 'will create a constant score query with the correct query and boost' do
+      expect(query.query).to eq match_query
+      expect(query.boost).to eq 5.0
+    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 a filter and a boost specified' do
+    let(:query) do
+      subject.new(filter: term_filter, boost: 5)
+    end
+
+    it 'will create a constant score query with the correct filter and boost' do
+      expect(query.filter).to eq term_filter
+      expect(query.boost).to eq 5.0
+    end
+    it 'will have the correct hash representation' do
+      expect(query.to_hash).to eq hash_filter
+    end
+    it 'will have the correct json representation' do
+      expect(query.to_json).to eq hash_filter.to_json
+    end
+  end
+end