arelastic 0.0.1

data/lib/arelastic/arities/binary.rb

@@ -0,0 +1,31 @@
+module Arelastic
+  module Arities
+    module Binary
+      def binary(predicate)
+        @predicate = predicate
+        include Methods
+
+        singleton_class.class_eval do
+          attr_reader :predicate
+        end
+
+        attr_reader :field, :value
+      end
+
+      module Methods
+        def initialize field, value
+          @field = field
+          @value = value
+        end
+
+        def as_elastic
+          {
+            self.class.predicate => {
+              field => convert_to_elastic(value)
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/arelastic/arities/polyadic.rb

@@ -0,0 +1,26 @@
+module Arelastic
+  module Arities
+    module Polyadic
+      def polyadic(operator)
+        @operator = operator
+        include Methods
+
+        singleton_class.class_eval do
+          attr_reader :operator
+        end
+
+        attr_reader :children
+      end
+
+      module Methods
+        def initialize children
+          @children = children
+        end
+
+        def as_elastic
+          {self.class.operator => children.map { |child| convert_to_elastic(child) }}
+        end
+      end
+    end
+  end
+end

data/lib/arelastic/arities/unary.rb

@@ -0,0 +1,27 @@
+module Arelastic
+  module Arities
+    module Unary
+      def unary(field, options = {})
+        @field = field
+        include Methods
+
+        singleton_class.class_eval do
+          attr_reader :field
+        end
+
+        attr_reader :expr
+      end
+
+      module Methods
+        def initialize expr
+          # raise "#{expr.inspect} must be an Arelastic::Filters::Filter" unless expr.is_a?(Arelastic::Filters::Filter)
+          @expr = expr
+        end
+
+        def as_elastic
+          {self.class.field => convert_to_elastic(expr)}
+        end
+      end
+    end
+  end
+end

data/lib/arelastic/arities.rb

@@ -0,0 +1,3 @@
+require 'arelastic/arities/binary'
+require 'arelastic/arities/polyadic'
+require 'arelastic/arities/unary'

data/lib/arelastic/builders/facet.rb

@@ -0,0 +1,19 @@
+module Arelastic
+  module Builders
+    class Facet < Struct.new :name
+      class << self
+        def [](name)
+          new(name)
+        end
+      end
+
+      def terms field, options = {}
+        Arelastic::Facets::Terms.new name, field, options
+      end
+
+      def histogram options
+        Arelastic::Facets::Histogram.new name, options
+      end
+    end
+  end
+end

data/lib/arelastic/builders/filter.rb

@@ -0,0 +1,77 @@
+module Arelastic
+  module Builders
+    class Filter < Struct.new :field
+      class << self
+        def [](field)
+          new(field)
+        end
+
+        def ids *ids
+          Arelastic::Filters::Ids.new ids.flatten
+        end
+      end
+
+      def eq other
+        Arelastic::Filters::Term.new field, other
+      end
+
+      def not_eq other
+        self.not eq(other)
+      end
+
+      def in other
+        case other
+        when Range
+          if other.exclude_end?
+            range 'gte' => other.begin, 'lt' => other.end
+          else
+            range 'gte' => other.begin, 'lte' => other.end
+          end
+        else
+          Arelastic::Filters::Terms.new field, other
+        end
+      end
+
+      def not_in other
+        self.not self.in(other)
+      end
+
+      def prefix other
+        Arelastic::Filters::Prefix.new field, other
+      end
+
+      def exists
+        Arelastic::Filters::Exists.new field
+      end
+
+      def missing(options = {})
+        Arelastic::Filters::Missing.new field, options
+      end
+
+      def gteq other
+        range 'gte' => other
+      end
+
+      def gt other
+        range 'gt' => other
+      end
+
+      def lteq other
+        range 'lte' => other
+      end
+
+      def lt other
+        range 'lt' => other
+      end
+
+      def not other
+        Arelastic::Filters::Not.new other
+      end
+
+      private
+        def range options
+          Arelastic::Filters::Range.new field, options
+        end
+    end
+  end
+end

data/lib/arelastic/builders/query.rb

@@ -0,0 +1,39 @@
+module Arelastic
+  module Builders
+    class Query < Struct.new :name
+      class << self
+        def [](field)
+          new(field)
+        end
+        def constant_score(filter_or_query)
+          query Arelastic::Queries::ConstantScore.new(filter_or_query)
+        end
+
+        def filtered(query, filter)
+          query Arelastic::Queries::Filtered.new(query, filter)
+        end
+
+        def match_all
+          query Arelastic::Queries::MatchAll.new
+        end
+
+        private
+          def query value
+            Arelastic::Searches::Query.new value
+          end
+      end
+
+      def field other
+        Arelastic::Queries::Field.new name, other
+      end
+
+      def term other
+        Arelastic::Queries::Term.new name, other
+      end
+
+      def terms other
+        Arelastic::Queries::Terms.new name, other
+      end
+    end
+  end
+end

data/lib/arelastic/builders/search.rb

@@ -0,0 +1,25 @@
+module Arelastic
+  module Builders
+    class Search
+      def filter
+        Arelastic::Builders::Filter
+      end
+
+      def [](field)
+        filter[field]
+      end
+
+      def facet
+        Arelastic::Builders::Facet
+      end
+
+      def query
+        Arelastic::Builders::Query
+      end
+
+      def sort
+        Arelastic::Builders::Sort
+      end
+    end
+  end
+end

data/lib/arelastic/builders/sort.rb

@@ -0,0 +1,15 @@
+module Arelastic
+  module Builders
+    class Sort < Struct.new :field
+      class << self
+        def [](field)
+          new(field)
+        end
+      end
+
+      def asc
+        
+      end
+    end
+  end
+end

data/lib/arelastic/builders.rb

@@ -0,0 +1,4 @@
+require 'arelastic/builders/filter'
+require 'arelastic/builders/facet'
+require 'arelastic/builders/query'
+require 'arelastic/builders/search'

data/lib/arelastic/facets/facet.rb

@@ -0,0 +1,6 @@
+module Arelastic
+  module Facets
+    class Facet < Arelastic::Nodes::Node
+    end
+  end
+end

data/lib/arelastic/facets/histogram.rb

@@ -0,0 +1,19 @@
+module Arelastic
+  module Facets
+    class Histogram < Arelastic::Facets::Facet
+      attr_accessor :name, :options
+      def initialize name, options
+        @name = name
+        @options = options
+      end
+
+      def as_elastic
+        {
+          name => {
+            "histogram" => options
+          }
+        }
+      end
+    end
+  end
+end

data/lib/arelastic/facets/terms.rb

@@ -0,0 +1,22 @@
+module Arelastic
+  module Facets
+    class Terms < Arelastic::Facets::Facet
+      attr_accessor :name, :field, :options
+      def initialize name, field, options = {}
+        @name = name
+        @field = field
+        @options = options
+      end
+
+      def as_elastic
+        params = {"field" => field}.update(options)
+
+        {
+          name => {
+            "terms" => params
+          }
+        }
+      end
+    end
+  end
+end

data/lib/arelastic/facets.rb

@@ -0,0 +1,5 @@
+require 'arelastic/facets/facet'
+
+require 'arelastic/facets/histogram'
+require 'arelastic/facets/range'
+require 'arelastic/facets/terms'

data/lib/arelastic/filters/and.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Filters
+    class And < Arelastic::Filters::Filter
+      polyadic 'and'
+    end
+  end
+end

data/lib/arelastic/filters/exists.rb

@@ -0,0 +1,15 @@
+module Arelastic
+  module Filters
+    class Exists < Arelastic::Filters::Filter
+      attr_reader :field
+
+      def initialize field
+        @field = field
+      end
+
+      def as_elastic
+        {"exists" => { "field" => field }}
+      end
+    end
+  end
+end

data/lib/arelastic/filters/filter.rb

@@ -0,0 +1,17 @@
+module Arelastic
+  module Filters
+    class Filter < Arelastic::Nodes::Node
+      def or other
+        Arelastic::Filters::Or.new [self, other]
+      end
+
+      def and other
+        Arelastic::Filters::And.new [self, other]
+      end
+
+      def negate
+        Arelastic::Filters::Not.new self
+      end
+    end
+  end
+end

data/lib/arelastic/filters/ids.rb

@@ -0,0 +1,16 @@
+module Arelastic
+  module Filters
+    class Ids < Arelastic::Filters::Filter
+      attr_reader :values
+
+      def initialize values
+        @values = values
+      end
+
+      def as_elastic
+        { "ids" => { "values" => values }}
+      end
+    end
+  end
+end
+

data/lib/arelastic/filters/limit.rb

@@ -0,0 +1,15 @@
+module Arelastic
+  module Filters
+    class Limit < Arelastic::Filters::Filter
+      attr_reader :value
+
+      def initialize value
+        @value = value
+      end
+
+      def as_elastic
+        {"limit" => {"value" => value}}
+      end
+    end
+  end
+end

data/lib/arelastic/filters/missing.rb

@@ -0,0 +1,20 @@
+module Arelastic
+  module Filters
+    class Missing < Arelastic::Filters::Filter
+      attr_reader :field, :options
+
+      # Options:
+      #   "existence" => true defaults to true
+      #   "null_value" => true defaults to false
+      def initialize field, options = {}
+        @field = field
+        @options = options
+      end
+
+      def as_elastic
+        params = {"field" => field}.update(options)
+        {"missing" => params}
+      end
+    end
+  end
+end

data/lib/arelastic/filters/not.rb

@@ -0,0 +1,15 @@
+module Arelastic
+  module Filters
+    class Not < Arelastic::Filters::Filter
+      attr_reader :expr
+
+      def initialize expr
+        @expr = expr
+      end
+
+      def as_elastic
+        {"not" => convert_to_elastic(expr)}
+      end
+    end
+  end
+end

data/lib/arelastic/filters/or.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Filters
+    class Or < Arelastic::Filters::Filter
+      polyadic 'or'
+    end
+  end
+end

data/lib/arelastic/filters/prefix.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Filters
+    class Prefix < Arelastic::Filters::Filter
+      binary 'prefix'
+    end
+  end
+end

data/lib/arelastic/filters/range.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Filters
+    class Range < Arelastic::Filters::Filter
+      binary 'range'
+    end
+  end
+end

data/lib/arelastic/filters/term.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Filters
+    class Term < Arelastic::Filters::Filter
+      binary 'term'
+    end
+  end
+end

data/lib/arelastic/filters/terms.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Filters
+    class Terms < Arelastic::Filters::Filter
+      binary 'terms'
+    end
+  end
+end

data/lib/arelastic/filters.rb

@@ -0,0 +1,13 @@
+require 'arelastic/filters/filter'
+
+require 'arelastic/filters/and'
+require 'arelastic/filters/exists'
+require 'arelastic/filters/ids'
+require 'arelastic/filters/limit'
+require 'arelastic/filters/missing'
+require 'arelastic/filters/not'
+require 'arelastic/filters/or'
+require 'arelastic/filters/prefix'
+require 'arelastic/filters/range'
+require 'arelastic/filters/term'
+require 'arelastic/filters/terms'

data/lib/arelastic/nodes/hash_group.rb

@@ -0,0 +1,18 @@
+module Arelastic
+  module Nodes
+    class HashGroup < Arelastic::Nodes::Node
+      attr_accessor :nodes
+      def initialize nodes
+        @nodes = nodes
+      end
+
+      def as_elastic
+        result = {}
+        nodes.each do |node|
+          result.merge! convert_to_elastic(node)
+        end
+        result
+      end
+    end
+  end
+end

data/lib/arelastic/nodes/node.rb

@@ -0,0 +1,17 @@
+module Arelastic
+  module Nodes
+    class Node
+      extend Arelastic::Arities::Binary
+      extend Arelastic::Arities::Polyadic
+      extend Arelastic::Arities::Unary
+
+      def convert_to_elastic(expr)
+        expr.respond_to?(:as_elastic) ? expr.as_elastic : expr
+      end
+
+      def ==(other)
+        as_elastic == other.as_elastic
+      end
+    end
+  end
+end

data/lib/arelastic/nodes.rb

@@ -0,0 +1,2 @@
+require 'arelastic/nodes/node'
+require 'arelastic/nodes/hash_group'

data/lib/arelastic/queries/constant_score.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Queries
+    class ConstantScore < Arelastic::Queries::Query
+      unary 'constant_score'
+    end
+  end
+end

data/lib/arelastic/queries/field.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Queries
+    class Field < Arelastic::Queries::Query
+      binary 'field'
+    end
+  end
+end

data/lib/arelastic/queries/filtered.rb

@@ -0,0 +1,15 @@
+module Arelastic
+  module Queries
+    class Filtered < Arelastic::Queries::Query
+      attr_accessor :query, :filter
+      def initialize(query, filter)
+        @query = query
+        @filter = filter
+      end
+
+      def as_elastic
+        { "filtered" => Arelastic::Nodes::HashGroup.new([query, filter]).as_elastic }
+      end
+    end
+  end
+end

data/lib/arelastic/queries/match_all.rb

@@ -0,0 +1,9 @@
+module Arelastic
+  module Queries
+    class MatchAll
+      def as_elastic
+        {"match_all" => {}}
+      end
+    end
+  end
+end

data/lib/arelastic/queries/prefix.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Queries
+    class Prefix < Arelastic::Queries::Query
+      binary 'prefix'
+    end
+  end
+end

data/lib/arelastic/queries/query.rb

@@ -0,0 +1,6 @@
+module Arelastic
+  module Queries
+    class Query < Arelastic::Nodes::Node
+    end
+  end
+end

data/lib/arelastic/queries/query_string.rb

@@ -0,0 +1,17 @@
+module Arelastic
+  module Queries
+    class QueryString < Arelastic::Queries::Query
+      attr_accessor :query_string
+      attr_accessor :options
+
+      def initialize(query_string, options = {})
+        @query_string = query_string
+        @options = options
+      end
+
+      def as_elastic
+        {"query_string" => {"query" => query_string}}
+      end
+    end
+  end
+end

data/lib/arelastic/queries/term.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Queries
+    class Term < Arelastic::Queries::Query
+      binary 'term'
+    end
+  end
+end

data/lib/arelastic/queries/terms.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Queries
+    class Terms < Arelastic::Queries::Query
+      binary 'terms'
+    end
+  end
+end

data/lib/arelastic/queries.rb

@@ -0,0 +1,10 @@
+require 'arelastic/queries/query'
+
+require 'arelastic/queries/constant_score'
+require 'arelastic/queries/field'
+require 'arelastic/queries/filtered'
+require 'arelastic/queries/match_all'
+require 'arelastic/queries/prefix'
+require 'arelastic/queries/query_string'
+require 'arelastic/queries/terms'
+require 'arelastic/queries/term'

data/lib/arelastic/searches/facets.rb

@@ -0,0 +1,14 @@
+module Arelastic
+  module Searches
+    class Facets < Arelastic::Searches::Search
+      attr_accessor :grouping
+      def initialize facets
+        @grouping = Arelastic::Nodes::HashGroup.new facets
+      end
+
+      def as_elastic
+        { "facets" => convert_to_elastic(grouping) }
+      end
+    end
+  end
+end

data/lib/arelastic/searches/filter.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Searches
+    class Filter < Arelastic::Searches::Search
+      unary 'filter', expects: Arelastic::Filters::Filter
+    end
+  end
+end

data/lib/arelastic/searches/from.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Searches
+    class From < Arelastic::Searches::Search
+      unary 'from'
+    end
+  end
+end

data/lib/arelastic/searches/query.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Searches
+    class Query < Arelastic::Searches::Search
+      unary 'query', expects: Arelastic::Queries::Query
+    end
+  end
+end

data/lib/arelastic/searches/search.rb

@@ -0,0 +1,6 @@
+module Arelastic
+  module Searches
+    class Search < Arelastic::Nodes::Node
+    end
+  end
+end

data/lib/arelastic/searches/size.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Searches
+    class Size < Arelastic::Searches::Search
+      unary 'size'
+    end
+  end
+end

data/lib/arelastic/searches/sort.rb

@@ -0,0 +1,7 @@
+module Arelastic
+  module Searches
+    class Sort < Arelastic::Searches::Search
+      unary 'sort'
+    end
+  end
+end

data/lib/arelastic/searches.rb

@@ -0,0 +1,8 @@
+require 'arelastic/searches/search'
+
+require 'arelastic/searches/facets'
+require 'arelastic/searches/filter'
+require 'arelastic/searches/from'
+require 'arelastic/searches/query'
+require 'arelastic/searches/size'
+require 'arelastic/searches/sort'

data/lib/arelastic.rb

@@ -0,0 +1,8 @@
+require 'arelastic/arities'
+require 'arelastic/nodes'
+require 'arelastic/facets'
+require 'arelastic/filters'
+require 'arelastic/queries'
+require 'arelastic/searches'
+
+require 'arelastic/builders'

data/test/arelastic/arities/binary_test.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+class Arelastic::Arities::BinaryTest < MiniTest::Spec
+  def test_binary
+    node = Class.new(Arelastic::Nodes::Node) do
+      binary 'suffix'
+    end
+
+    expected = {'suffix' => {'phone' => '666'}}
+    assert_equal expected, node.new('phone', '666').as_elastic
+  end
+end

data/test/arelastic/arities/polyadic_test.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+class Arelastic::Arities::PolyadicTest < MiniTest::Spec
+  def test_polyadic
+    expr = Struct.new(:as_elastic)
+    node = Class.new(Arelastic::Nodes::Node) do
+      polyadic 'xor'
+    end
+
+    expected = {'xor' => [{'a' => 'b'}, {'x' => 'y'}]}
+    assert_equal expected, node.new([expr.new('a' => 'b'), expr.new('x' => 'y')]).as_elastic
+  end
+end

data/test/arelastic/arities/unary_test.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+class Arelastic::Arities::UnaryTest < MiniTest::Spec
+  def test_unary
+    node = Class.new(Arelastic::Nodes::Node) do
+      unary 'unicorn'
+    end
+
+    expected = {'unicorn' => 'serenity'}
+    assert_equal expected, node.new('serenity').as_elastic
+  end
+end

data/test/arelastic/builders/filter_test.rb

@@ -0,0 +1,56 @@
+require 'helper'
+
+class Arelastic::Builders::FilterTest < MiniTest::Spec
+  def test_ids
+    expected = {"ids" => {"values"=>["5", "6"]}}
+    assert_equal expected, Arelastic::Builders::Filter.ids('5', '6').as_elastic
+  end
+
+  def test_eq
+    expected = {"term"=>{"color"=>"blue"}}
+    assert_equal expected, builder.eq('blue').as_elastic
+  end
+
+  def test_not_eq
+    expected = {"not" => {"term" => {"color"=>"blue"}}}
+    assert_equal expected, builder.not_eq('blue').as_elastic
+  end
+
+  def test_in
+    expected = {"terms" => {"color"=>["blue"]}}
+    assert_equal expected, builder.in(['blue']).as_elastic
+  end
+
+  def test_in_with_range
+    expected = {"range" => {"color" => {"gte"=>1, "lte"=>3}}}
+    assert_equal expected, builder.in(1..3).as_elastic
+
+    expected = {"range" => {"color" => {"gte"=>1, "lt"=>3}}}
+    assert_equal expected, builder.in(1...3).as_elastic
+  end
+
+  def test_not_in
+    expected = {"not" => {"terms" => {"color"=>["blue"]}}}
+    assert_equal expected, builder.not_in(['blue']).as_elastic
+  end
+
+  def test_prefix
+    expected = {"prefix" => {"color" => "blu"}}
+    assert_equal expected, builder.prefix('blu').as_elastic
+  end
+
+  def test_exists
+    expected = {"exists" => {"field"=>"color"}}
+    assert_equal expected, builder.exists.as_elastic
+  end
+
+  def test_range
+    expected = {"range" => {"color" => {"lt" => 5}}}
+    assert_equal expected, builder.lt(5).as_elastic
+  end
+
+  private
+    def builder
+      @builder ||= Arelastic::Builders::Filter['color']
+    end
+end

data/test/arelastic/builders/query_test.rb

@@ -0,0 +1,45 @@
+require 'helper'
+
+class Arelastic::Builders::QueryTest < MiniTest::Spec
+  def test_constant_score
+    query = Arelastic::Builders::Query.constant_score({"foo" => "bar"})
+    expected = {"query" => {"constant_score" => {"foo" => "bar"}}}
+
+    assert_equal expected, query.as_elastic
+  end
+
+  def test_filtered
+    query = Arelastic::Builders::Query.filtered({"query" => "foo"}, {"filter" => "bar"})
+    expected = {"query" => {"filtered" => {"query" => "foo", "filter" => "bar"}}}
+
+    assert_equal expected, query.as_elastic
+  end
+
+  def test_match_all
+    query = Arelastic::Builders::Query.match_all
+    expected = {"query" => {"match_all" => {}}}
+
+    assert_equal expected, query.as_elastic
+  end
+
+  def test_field
+    query = Arelastic::Builders::Query['user'].field 'kimchy'
+    expected = { "field" => { "user" => "kimchy" } }
+
+    assert_equal expected, query.as_elastic
+  end
+
+  def test_term
+    query = Arelastic::Builders::Query['user'].term 'kimchy'
+    expected = {"term" => { "user" => "kimchy" }}
+
+    assert_equal expected, query.as_elastic
+  end
+
+  def test_term
+    query = Arelastic::Builders::Query['tags'].terms ['blue', 'pill']
+    expected = {"terms" => { "tags" => ["blue", "pill"] }}
+    
+    assert_equal expected, query.as_elastic
+  end
+end

data/test/arelastic/builders/search_test.rb

@@ -0,0 +1,4 @@
+require 'helper'
+
+class Arelastic::Builders::SearchTest < MiniTest::Spec
+end

data/test/arelastic/builders/sort_test.rb

@@ -0,0 +1,5 @@
+require 'helper'
+
+class Arelastic::Builders::SortTest < MiniTest::Spec
+  
+end

data/test/arelastic/facets/histogram_test.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+class Arelastic::Facets::TermsTest < MiniTest::Spec
+  def test_as_elastic
+    facet = Arelastic::Facets::Histogram.new('histo', "field" => "field_name", "interval" => 100)
+    expected = {
+      "histo" => {
+        "histogram" => {
+          "field" => "field_name",
+          "interval" => 100
+        }
+      }
+    }
+
+    assert_equal expected, facet.as_elastic
+  end
+end

data/test/arelastic/facets/terms_test.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+class Arelastic::Facets::TermsTest < MiniTest::Spec
+  def test_as_elastic
+    facet = Arelastic::Facets::Terms.new('foo', 'tags', "size" => 10)
+    expected = {
+      "foo" => {
+        "terms" => {
+          "field" => "tags",
+          "size"  => 10,
+        }
+      }
+    }
+
+    assert_equal expected, facet.as_elastic
+  end
+end

data/test/arelastic/filters/exists_test.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+class Arelastic::Filters::ExistsTest < MiniTest::Spec
+  def test_as_elastic
+    expected = {"exists" => { "field" => "color" }}
+
+    assert_equal expected, Arelastic::Filters::Exists.new('color').as_elastic
+  end
+end

data/test/arelastic/filters/filter_test.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+class Arelastic::FilterTest < MiniTest::Spec
+  def test_or
+    filter = Arelastic::Filters::Filter.new
+
+    and_filter = filter.and(filter)
+
+    assert and_filter.is_a?(Arelastic::Filters::And)
+    assert_equal [filter, filter], and_filter.children
+  end
+
+  def test_and
+    filter = Arelastic::Filters::Filter.new
+
+    and_filter = filter.or(filter)
+
+    assert and_filter.is_a?(Arelastic::Filters::Or)
+    assert_equal [filter, filter], and_filter.children
+  end
+
+  def test_negate
+    filter = Arelastic::Filters::Term.new 'foo', 'bar'
+
+    negated_filter = filter.negate
+
+    assert negated_filter.is_a?(Arelastic::Filters::Not)
+    assert_equal filter, negated_filter.expr
+  end
+end

data/test/arelastic/filters/ids_test.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+class Arelastic::Filters::IdsTest < MiniTest::Spec
+  def test_as_elastic
+    expected = {"ids" => {"values" => ["foo", "bar"]}}
+
+    assert_equal expected, Arelastic::Filters::Ids.new(['foo', 'bar']).as_elastic
+  end
+end

data/test/arelastic/filters/missing_test.rb

@@ -0,0 +1,15 @@
+require 'helper'
+
+class Arelastic::Filters::MissingTest < MiniTest::Spec
+  def test_as_elastic
+    expected = {"missing" => { "field" => "color" }}
+
+    assert_equal expected, Arelastic::Filters::Missing.new('color').as_elastic
+  end
+
+  def test_with_options
+    expected = {"missing" => { "field" => "color", "null_value" => true }}
+
+    assert_equal expected, Arelastic::Filters::Missing.new('color', 'null_value' => true).as_elastic
+  end
+end

data/test/arelastic/filters/not_test.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+class Arelastic::Filters::NotTest < MiniTest::Spec
+  def test_as_elastic
+    expected = {"not" => { "foo" => "bar" }}
+
+    assert_equal expected, Arelastic::Filters::Not.new('foo' => 'bar').as_elastic
+  end
+end

data/test/arelastic/nodes/node_test.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+class Arelastic::Nodes::NodeTest < MiniTest::Spec
+  def test_equality
+    node = Class.new(Arelastic::Nodes::Node) do
+      def initialize(value)
+        @value = value
+      end
+
+      def as_elastic
+        {"value" => @value}
+      end
+    end
+
+    assert_equal node.new('foo'), node.new('foo')
+    refute_equal node.new('foo'), node.new('bar')
+  end
+end

data/test/arelastic/queries/filtered_test.rb

@@ -0,0 +1,10 @@
+require 'helper'
+
+class Arelastic::Queries::FilteredTest < MiniTest::Spec
+  def test_as_elastic
+    filtered = Arelastic::Queries::Filtered.new({"query" => "bar"}, {"filter" => "baz"})
+    expected = {"filtered" => {"query" => "bar", "filter" => "baz"}}
+
+    assert_equal expected, filtered.as_elastic
+  end
+end

data/test/arelastic/queries/match_all_test.rb

@@ -0,0 +1,10 @@
+require 'helper'
+
+class Arelastic::Queries::MatchAllTest < MiniTest::Spec
+  def test_as_elastic
+    match_all = Arelastic::Queries::MatchAll.new
+    expected = {"match_all" => {}}
+
+    assert_equal expected, match_all.as_elastic
+  end
+end

data/test/arelastic/queries/query_string_test.rb

@@ -0,0 +1,10 @@
+require 'helper'
+
+class Arelastic::Queries::QueryStringTest < MiniTest::Spec
+  def test_as_elastic
+    query_string = Arelastic::Queries::QueryString.new('foo')
+    expected = {"query_string" => {"query" => "foo"}}
+
+    assert_equal expected, query_string.as_elastic
+  end
+end

data/test/arelastic/queries/query_test.rb

@@ -0,0 +1,5 @@
+require 'helper'
+
+class Arelastic::Queries::QueryTest < MiniTest::Spec
+  
+end

data/test/helper.rb

@@ -0,0 +1,4 @@
+require 'bundler/setup'
+Bundler.require
+
+require 'minitest/autorun'

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: arelastic
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matthew Higgins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-23 00:00:00.000000000 Z
+dependencies: []
+description: Build Elastic Search queries with objects
+email: developer@matthewhiggins.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- lib/arelastic/arities/binary.rb
+- lib/arelastic/arities/polyadic.rb
+- lib/arelastic/arities/unary.rb
+- lib/arelastic/arities.rb
+- lib/arelastic/builders/facet.rb
+- lib/arelastic/builders/filter.rb
+- lib/arelastic/builders/query.rb
+- lib/arelastic/builders/search.rb
+- lib/arelastic/builders/sort.rb
+- lib/arelastic/builders.rb
+- lib/arelastic/facets/facet.rb
+- lib/arelastic/facets/histogram.rb
+- lib/arelastic/facets/range.rb
+- lib/arelastic/facets/terms.rb
+- lib/arelastic/facets.rb
+- lib/arelastic/filters/and.rb
+- lib/arelastic/filters/exists.rb
+- lib/arelastic/filters/filter.rb
+- lib/arelastic/filters/ids.rb
+- lib/arelastic/filters/limit.rb
+- lib/arelastic/filters/missing.rb
+- lib/arelastic/filters/not.rb
+- lib/arelastic/filters/or.rb
+- lib/arelastic/filters/prefix.rb
+- lib/arelastic/filters/range.rb
+- lib/arelastic/filters/term.rb
+- lib/arelastic/filters/terms.rb
+- lib/arelastic/filters.rb
+- lib/arelastic/nodes/hash_group.rb
+- lib/arelastic/nodes/node.rb
+- lib/arelastic/nodes.rb
+- lib/arelastic/queries/constant_score.rb
+- lib/arelastic/queries/field.rb
+- lib/arelastic/queries/filtered.rb
+- lib/arelastic/queries/match_all.rb
+- lib/arelastic/queries/prefix.rb
+- lib/arelastic/queries/query.rb
+- lib/arelastic/queries/query_string.rb
+- lib/arelastic/queries/term.rb
+- lib/arelastic/queries/terms.rb
+- lib/arelastic/queries.rb
+- lib/arelastic/searches/facets.rb
+- lib/arelastic/searches/filter.rb
+- lib/arelastic/searches/from.rb
+- lib/arelastic/searches/query.rb
+- lib/arelastic/searches/search.rb
+- lib/arelastic/searches/size.rb
+- lib/arelastic/searches/sort.rb
+- lib/arelastic/searches.rb
+- lib/arelastic.rb
+- test/arelastic/arities/binary_test.rb
+- test/arelastic/arities/polyadic_test.rb
+- test/arelastic/arities/unary_test.rb
+- test/arelastic/builders/filter_test.rb
+- test/arelastic/builders/query_test.rb
+- test/arelastic/builders/search_test.rb
+- test/arelastic/builders/sort_test.rb
+- test/arelastic/facets/histogram_test.rb
+- test/arelastic/facets/terms_test.rb
+- test/arelastic/filters/exists_test.rb
+- test/arelastic/filters/filter_test.rb
+- test/arelastic/filters/ids_test.rb
+- test/arelastic/filters/missing_test.rb
+- test/arelastic/filters/not_test.rb
+- test/arelastic/nodes/node_test.rb
+- test/arelastic/queries/filtered_test.rb
+- test/arelastic/queries/match_all_test.rb
+- test/arelastic/queries/query_string_test.rb
+- test/arelastic/queries/query_test.rb
+- test/helper.rb
+- README.rdoc
+homepage: http://github.com/matthuhiggins/arelastic
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.11
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Elastic Search query builder
+test_files: []