daedal-sl 0.0.0 → 0.0.1

data/lib/daedal-sl/builder.rb

@@ -0,0 +1,58 @@
+module DaedalSL
+  class Builder
+    include DaedalSL::QueryHelpers
+
+    attr_reader :data
+
+    def initialize(data=nil)
+      @data = data
+      @query = match_all
+      @filter = nil
+      @options = {}
+    end
+
+    def query
+      if block_given?
+        @query = yield
+      end
+    end
+
+    def filter
+      if block_given?
+        @filter = yield
+      end
+    end
+
+    def from(num)
+      @options[:from] = num
+    end
+
+    def size(num)
+      @options[:size] = num
+    end
+
+    def fields(*f)
+      @options[:fields] = f
+    end
+
+    def paginate(options={})
+      page = options[:page] || 1
+      per_page = options[:per_page] || 10
+
+      from ((page - 1) * per_page)
+      size per_page
+    end
+
+    def to_hash
+      result = {}
+      unless @query.nil?
+        result[:query] = @query.to_hash
+      end
+      unless @filter.nil?
+        result[:filter] = @filter.to_hash
+      end
+      result.merge(@options)
+    end
+
+  end
+end

data/lib/daedal-sl/dis_max_query.rb

@@ -0,0 +1,16 @@
+module DaedalSL
+  class DisMaxQuery < BlockQuery
+
+    def initialize(parent, options)
+      @query_type = Daedal::Queries::DisMaxQuery
+      super
+    end
+
+    def query
+      if (result = yield)
+        @base.queries << result
+      end
+    end
+
+  end
+end

data/lib/daedal-sl/nested_bool_filter.rb

@@ -0,0 +1,28 @@
+module DaedalSL
+  class NestedBoolFilter < BlockQuery
+
+    def initialize(parent, options)
+      @parent = parent
+      @base = Daedal::Filters::NestedFilter.new(options.merge(filter: Daedal::Filters::BoolFilter.new))
+    end
+
+    def must
+      if (result = yield)
+        @base.filter.must << result
+      end
+    end
+
+    def should
+      if (result = yield)
+        @base.filter.should << result
+      end
+    end
+
+    def must_not
+      if (result = yield)
+        @base.filter.must_not << result
+      end
+    end
+
+  end
+end

data/lib/daedal-sl/nested_bool_query.rb

@@ -0,0 +1,28 @@
+module DaedalSL
+  class NestedBoolQuery < BlockQuery
+
+    def initialize(parent, options)
+      @parent = parent
+      @base = Daedal::Queries::NestedQuery.new(options.merge(query: Daedal::Queries::BoolQuery.new))
+    end
+
+    def must
+      if (result = yield)
+        @base.query.must << result
+      end
+    end
+
+    def should
+      if (result = yield)
+        @base.query.should << result
+      end
+    end
+
+    def must_not
+      if (result = yield)
+        @base.query.must_not << result
+      end
+    end
+
+  end
+end

data/lib/daedal-sl/nested_dis_max_query.rb

@@ -0,0 +1,16 @@
+module DaedalSL
+  class NestedDisMaxQuery < BlockQuery
+
+    def initialize(parent, options)
+      @parent = parent
+      @base = Daedal::Queries::NestedQuery.new(options.merge(query: Daedal::Queries::DisMaxQuery.new))
+    end
+
+    def query
+      if (result = yield)
+        @base.query.queries << result
+      end
+    end
+
+  end
+end

data/lib/daedal-sl/or_filter.rb

@@ -0,0 +1,16 @@
+module DaedalSL
+  class OrFilter < BlockQuery
+
+    def initialize(parent, options)
+      @query_type = Daedal::Filters::OrFilter
+      super
+    end
+
+    def filter
+      if (result = yield)
+        @base.filters << result
+      end
+    end
+
+  end
+end

data/lib/daedal-sl/query_helpers.rb

@@ -0,0 +1,91 @@
+module DaedalSL
+  module QueryHelpers
+    include Daedal::Queries
+    include Daedal::Filters
+
+    def and_filter(options={}, &block)
+      DaedalSL::AndFilter.build(self, options, &block)
+    end
+
+    def bool_filter(options={}, &block)
+      DaedalSL::BoolFilter.build(self, options, &block)
+    end
+
+    def bool_query(options={}, &block)
+      DaedalSL::BoolQuery.build(self, options, &block)
+    end
+
+    def constant_score(options)
+      ConstantScoreQuery.new(options)
+    end
+
+    def dis_max(options={}, &block)
+      DaedalSL::DisMaxQuery.build(self, options, &block)
+    end
+
+    def exists_filter(options)
+      ExistsFilter.new(options)
+    end
+
+    def filtered_query(options)
+      FilteredQuery.new(options)
+    end
+
+    def fuzzy(options)
+      FuzzyQuery.new(options)
+    end
+
+    def geo_distance_filter(options)
+      GeoDistanceFilter.new(options)
+    end
+
+    def match(options)
+      MatchQuery.new(options)
+    end
+
+    def match_all
+      MatchAllQuery.new
+    end
+
+    def multi_match(options)
+      MultiMatchQuery.new(options)
+    end
+
+    def nested_bool_query(options={}, &block)
+      DaedalSL::NestedBoolQuery.build(self, options, &block)
+    end
+
+    def nested_bool_filter(options={}, &block)
+      DaedalSL::NestedBoolFilter.build(self, options, &block)
+    end
+
+    def nested_dis_max_query(options={}, &block)
+      DaedalSL::NestedDisMaxQuery.build(self, options, &block)
+    end
+
+    def or_filter(options={}, &block)
+      DaedalSL::OrFilter.build(self, options, &block)
+    end
+
+    def prefix(options)
+      PrefixQuery.new(options)
+    end
+
+    def query_string(options)
+      QueryStringQuery.new(options)
+    end
+
+    def range_filter(options)
+      RangeFilter.new(options)
+    end
+
+    def term_filter(options)
+      TermFilter.new(options)
+    end
+
+    def terms_filter(options)
+      TermsFilter.new(options)
+    end
+
+  end
+end

data/lib/daedal-sl/version.rb

@@ -0,0 +1,3 @@
+module DaedalSL
+  VERSION = '0.0.1'
+end

data/spec/acceptance/daedal-sl_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+require 'hashie'
+
+describe DaedalSL do
+
+  context 'creating a complex query' do
+    it 'works' do
+      expected_result = {
+        query: {
+          bool: {
+            should: [
+              {
+                fuzzy: {
+                  foofoo: {
+                    value: "barbar"
+                  }
+                }
+              },
+              {
+                multi_match: {
+                  query: "barbar",
+                  fields: [:field1, :field2]
+                }
+              }
+            ],
+            must: [
+              {
+                nested: {
+                  path: :path,
+                  query: {
+                    bool: {
+                      should: [
+                        {
+                          match: {
+                            foofoo: {
+                              query: "barbar"
+                            }
+                          }
+                        }
+                      ], 
+                      must: [
+                        {
+                          match: {
+                            foofoo: {
+                              query: "barbar"
+                            }
+                          }
+                        }
+                      ],
+                      must_not: []
+                    }
+                  }
+                }
+              }, 
+              {
+                nested: {
+                  path: :path,
+                  query: {
+                    dis_max: {
+                      queries: [
+                        {
+                          match: {
+                            foofoo: {
+                              query: "barbar"
+                            }
+                          }
+                        },
+                        {
+                          match: {
+                            foofoo: {
+                              query: "barbar"
+                            }
+                          }
+                        }
+                      ]
+                    }
+                  }
+                }
+              }
+            ],
+            must_not: [
+              {
+                match: {
+                  foofoo: {
+                    query: "barbar"
+                  }
+                }
+              }
+            ],
+            boost: 100.0
+          }
+        }, 
+        filter: {
+          bool: {
+            should: [
+              {
+                and: [
+                  {
+                    term: {
+                      foofoo: "barbar"
+                    }
+                  },
+                  {
+                    terms: {
+                      foofoo: ["term1", "term2"]
+                    }
+                  }
+                ]
+              }
+            ],
+            must: [
+              {
+                nested: {
+                  path: :path,
+                  filter: {
+                    bool: {
+                      should: [
+                        {
+                          term: {
+                            foofoo: "barbar"
+                          }
+                        }
+                      ],
+                      must: [
+                        {
+                          term: {
+                            foofoo: "barbar"
+                          }
+                        }
+                      ],
+                      must_not: []
+                    }
+                  }
+                }
+              }
+            ],
+            must_not: [
+              {
+                range: {
+                  foofoo: {
+                    lt: 2,
+                    gt: 1
+                  }
+                }
+              }
+            ]
+          }
+        },
+        fields: [:foo, :bar],
+        :from=>0,
+        :size=>10
+      }
+      data = Hashie::Mash.new({
+        foo: 'foofoo',
+        bar: 'barbar'
+      })
+      result = DaedalSL.build(data) do
+        query do
+          bool_query boost: 100 do
+            must do
+              nested_bool_query path: 'path' do
+                must { match field: data.foo, query: data.bar }
+                should { match field: data.foo, query: data.bar }
+              end
+            end
+            must do
+              nested_dis_max_query path: 'path' do
+                query { match field: data.foo, query: data.bar }
+                query { match field: data.foo, query: data.bar }
+              end
+            end
+            should { fuzzy field: data.foo, query: data.bar }
+            should { multi_match fields: ['field1', 'field2'], query: data.bar }
+            must_not { match field: data.foo, query: data.bar }
+          end
+        end
+        filter do
+          bool_filter do
+            must do
+              nested_bool_filter path: 'path' do
+                must { term_filter field: data.foo, term: data.bar }
+                should { term_filter field: data.foo, term: data.bar }
+              end
+            end
+            should do
+              and_filter do
+                filter { term_filter field: data.foo, term: data.bar }
+                filter { terms_filter field: data.foo, terms: ['term1', 'term2'] }
+              end
+            end
+            must_not { range_filter field: data.foo, gt: 1, lt: 2 }
+          end
+        end
+        fields :foo, :bar
+        paginate page: 1, per_page: 10
+      end
+      expect(result).to eq expected_result
+    end
+  end
+
+end