chewy 0.1.0 → 0.2.0

data/lib/chewy/index/actions.rb

@@ -1,41 +1,144 @@
 module Chewy
   class Index
+    # Module provides per-index actions, such as deletion,
+    # creation and existance check.
+    #
     module Actions
       extend ActiveSupport::Concern
 
       module ClassMethods
+        # Checks index existance. Returns true or false
+        #
+        #   UsersIndex.exist? #=> true
+        #
         def exists?
           client.indices.exists(index: index_name)
         end
 
-        def create
-          create!
+        # Creates index and applies mappings and settings.
+        # Returns false in case of unsuccessful creation.
+        #
+        #   UsersIndex.create # creates index named `users`
+        #
+        # Index name suffix might be passed optionally. In this case,
+        # method creates index with suffix and makes unsuffixed alias
+        # for it.
+        #
+        #   UsersIndex.create '01-2013' # creates index `uses_01-2013` and alias `users` for it
+        #   UsersIndex.create '01-2013', alias: false # creates index `uses_01-2013` only and no alias
+        #
+        # Suffixed index names might be used for zero-downtime mapping change, for example.
+        # Description: (http://www.elasticsearch.org/blog/changing-mapping-with-zero-downtime/).
+        #
+        def create *args
+          create! *args
         rescue Elasticsearch::Transport::Transport::Errors::BadRequest
           false
         end
 
-        def create!
-          client.indices.create(index: index_name, body: index_params)
+        # Creates index and applies mappings and settings.
+        # Raises elasticsearch-ruby transport error in case of
+        # unsuccessfull creation.
+        #
+        #   UsersIndex.create! # creates index named `users`
+        #
+        # Index name suffix might be passed optionally. In this case,
+        # method creates index with suffix and makes unsuffixed alias
+        # for it.
+        #
+        #   UsersIndex.create! '01-2014' # creates index `users_01-2014` and alias `users` for it
+        #   UsersIndex.create! '01-2014', alias: false # creates index `users_01-2014` only and no alias
+        #
+        # Suffixed index names might be used for zero-downtime mapping change, for example.
+        # Description: (http://www.elasticsearch.org/blog/changing-mapping-with-zero-downtime/).
+        #
+        def create! *args
+          options = args.extract_options!.reverse_merge!(alias: true)
+          name = build_index_name(suffix: args.first)
+          result = client.indices.create(index: name, body: index_params)
+          result &&= client.indices.put_alias(index: name, name: index_name) if options[:alias] && name != index_name
+          result
         end
 
-        def delete
-          delete!
+        # Deletes ES index. Returns false in case of error.
+        #
+        #   UsersIndex.delete # deletes `users` index
+        #
+        # Supports index suffix passed as the first argument
+        #
+        #   UsersIndex.delete '01-2014' # deletes `users_01-2014` index
+        #
+        def delete suffix = nil
+          delete! suffix
         rescue Elasticsearch::Transport::Transport::Errors::NotFound
           false
         end
 
-        def delete!
-          client.indices.delete(index: index_name)
+        # Deletes ES index. Raises elasticsearch-ruby transport error
+        # in case of error.
+        #
+        #   UsersIndex.delete # deletes `users` index
+        #
+        # Supports index suffix passed as the first argument
+        #
+        #   UsersIndex.delete '01-2014' # deletes `users_01-2014` index
+        #
+        def delete! suffix = nil
+          client.indices.delete index: build_index_name(suffix: suffix)
         end
 
-        def purge
-          delete
-          create
+        # Deletes and recreates index. Supports suffixes.
+        # Returns result of index creation.
+        #
+        #   UsersIndex.purge # deletes and creates `users` index
+        #   UsersIndex.purge '01-2014' # deletes `users` and `users_01-2014` indexes, creates `users_01-2014`
+        #
+        def purge suffix = nil
+          delete if suffix.present?
+          delete suffix
+          create suffix
         end
 
-        def purge!
-          delete
-          create!
+        # Deletes and recreates index. Supports suffixes.
+        # Returns result of index creation. Raises error in case
+        # of unsuccessfull creation
+        #
+        #   UsersIndex.purge! # deletes and creates `users` index
+        #   UsersIndex.purge! '01-2014' # deletes `users` and `users_01-2014` indexes, creates `users_01-2014`
+        #
+        def purge! suffix = nil
+          delete if suffix.present?
+          delete suffix
+          create! suffix
+        end
+
+        # Deletes, creates and imports data to the index.
+        # Returns import result
+        #
+        #   UsersIndex.reset!
+        #
+        # If index name suffix passed as the first argument - performs
+        # zero-downtime index resetting (described here:
+        # http://www.elasticsearch.org/blog/changing-mapping-with-zero-downtime/).
+        #
+        #   UsersIndex.reset! Time.now.to_i
+        #
+        def reset! suffix = nil
+          if suffix.present? && (indexes = self.indexes).any?
+            create! suffix, alias: false
+            result = import suffix: suffix
+            client.indices.update_aliases body: {actions: [
+              *indexes.map do |index|
+                {remove: {index: index, alias: index_name}}
+              end,
+              {add: {index: build_index_name(suffix: suffix), alias: index_name}}
+            ]}
+            client.indices.delete index: indexes if indexes.any?
+            result
+          else
+            purge! suffix
+            import
+          end
         end
       end
     end

data/lib/chewy/index/aliases.rb

@@ -0,0 +1,21 @@
+module Chewy
+  class Index
+    module Aliases
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def indexes
+          client.indices.get_alias(name: index_name).keys
+        rescue Elasticsearch::Transport::Transport::Errors::NotFound
+          []
+        end
+
+        def aliases
+          client.indices.get_alias(index: index_name, name: '*')[index_name].try(:[], 'aliases').try(:keys) || []
+        rescue Elasticsearch::Transport::Transport::Errors::NotFound
+          []
+        end
+      end
+    end
+  end
+end

data/lib/chewy/query.rb

@@ -4,7 +4,7 @@ rescue LoadError
 end
 
 require 'chewy/query/criteria'
-require 'chewy/query/context'
+require 'chewy/query/filters'
 require 'chewy/query/loading'
 require 'chewy/query/pagination'
 
@@ -281,7 +281,7 @@ module Chewy
     # See <tt>#filter_mode</tt> chainable method for more info.
     #
     # Also this method supports block DSL.
-    # See <tt>Chewy::Query::Context</tt> for more info.
+    # See <tt>Chewy::Query::Filters</tt> for more info.
     #
     #   UsersIndex.filter(term: {name: 'Johny'}).filter(range: {age: {lte: 42}})
     #   UsersIndex::User.filter(term: {name: 'Johny'}).filter(range: {age: {lte: 42}})
@@ -301,7 +301,7 @@ module Chewy
     #          }}}}
     #
     def filter params = nil, &block
-      params = Context.new(&block).__render__ if block
+      params = Filters.new(&block).__render__ if block
       chain { criteria.update_filters params }
     end
 
@@ -450,8 +450,8 @@ module Chewy
     def _results
       @_results ||= _response['hits']['hits'].map do |hit|
         attributes = hit['_source'] || hit['fields'] || {}
-        attributes.reverse_merge!(id: hit['_id']).merge!(_score: hit['_score'])
-        attributes.merge!(_explain: hit['_explanation']) if hit['_explanation']
+        attributes.reverse_merge!(id: hit['_id'])
+          .merge!(_score: hit['_score'], _explanation: hit['_explanation'])
         index.type_hash[hit['_type']].new attributes
       end
     end

data/lib/chewy/query/compose.rb

@@ -0,0 +1,59 @@
+module Chewy
+  class Query
+    module Compose
+
+    protected
+
+      def _composed_query queries, filters
+        if filters
+          {query: {
+            filtered: {
+              query: queries ? queries : {match_all: {}},
+              filter: filters
+            }
+          }}
+        elsif queries
+          {query: queries}
+        end
+      end
+
+      def _queries_join queries, logic
+        queries = queries.compact
+
+        if queries.many?
+          case logic
+          when :dis_max
+            {dis_max: {queries: queries}}
+          when :must, :should
+            {bool: {logic => queries}}
+          else
+            if logic.is_a?(Float)
+              {dis_max: {queries: queries, tie_breaker: logic}}
+            else
+              {bool: {should: queries, minimum_should_match: logic}}
+            end
+          end
+        else
+          queries.first
+        end
+      end
+
+      def _filters_join filters, logic
+        filters = filters.compact
+
+        if filters.many?
+          case logic
+          when :and, :or
+            {logic => filters}
+          when :must, :should
+            {bool: {logic => filters}}
+          else
+            {bool: {should: filters, minimum_should_match: logic}}
+          end
+        else
+          filters.first
+        end
+      end
+    end
+  end
+end

data/lib/chewy/query/criteria.rb

@@ -1,6 +1,9 @@
+require 'chewy/query/compose'
+
 module Chewy
   class Query
     class Criteria
+      include Compose
       STORAGES = [:options, :queries, :facets, :filters, :sort, :fields, :types]
 
       def initialize options = {}
@@ -36,11 +39,11 @@ module Chewy
       end
 
       def update_queries(modifer)
-        @queries = queries + Array.wrap(modifer).delete_if(&:blank?)
+        @queries = queries + Array.wrap(modifer).reject(&:blank?)
       end
 
       def update_filters(modifer)
-        @filters = filters + Array.wrap(modifer).delete_if(&:blank?)
+        @filters = filters + Array.wrap(modifer).reject(&:blank?)
       end
 
       def update_sort(modifer, options = {})
@@ -55,7 +58,7 @@ module Chewy
         define_method "update_#{storage}" do |modifer, options = {}|
           variable = "@#{storage}"
           instance_variable_set(variable, nil) if options[:purge]
-          modifer = send(storage) | Array.wrap(modifer).flatten.map(&:to_s).delete_if(&:blank?)
+          modifer = send(storage) | Array.wrap(modifer).flatten.map(&:to_s).reject(&:blank?)
           instance_variable_set(variable, modifer)
         end
       end
@@ -72,7 +75,7 @@ module Chewy
       end
 
       def request_body
-        body = (_request_query || {}).tap do |body|
+        body = (_composed_query(_request_query, _request_filter) || {}).tap do |body|
           body.merge!(facets: facets) if facets?
           body.merge!(sort: sort) if sort?
           body.merge!(fields: fields) if fields?
@@ -102,19 +105,7 @@ module Chewy
       end
 
       def _request_query
-        request_filter = _request_filter
-        request_query = _queries_join(queries, options[:query_mode])
-
-        if request_filter
-          {query: {
-            filtered: {
-              query: request_query ? request_query : {match_all: {}},
-              filter: request_filter
-            }
-          }}
-        elsif request_query
-          {query: request_query}
-        end
+        _queries_join(queries, options[:query_mode])
       end
 
       def _request_filter
@@ -131,44 +122,6 @@ module Chewy
       def _request_types
         _filters_join(types.map { |type| {type: {value: type}} }, :or)
       end
-
-      def _queries_join queries, logic
-        queries = queries.compact
-
-        if queries.many?
-          case logic
-          when :dis_max
-            {dis_max: {queries: queries}}
-          when :must, :should
-            {bool: {logic => queries}}
-          else
-            if logic.is_a?(Float)
-              {dis_max: {queries: queries, tie_breaker: logic}}
-            else
-              {bool: {should: queries, minimum_should_match: logic}}
-            end
-          end
-        else
-          queries.first
-        end
-      end
-
-      def _filters_join filters, logic
-        filters = filters.compact
-
-        if filters.many?
-          case logic
-          when :and, :or
-            {logic => filters}
-          when :must, :should
-            {bool: {logic => filters}}
-          else
-            {bool: {should: filters, minimum_should_match: logic}}
-          end
-        else
-          filters.first
-        end
-      end
     end
   end
 end

data/lib/chewy/query/{context.rb → filters.rb}

@@ -14,6 +14,9 @@ require 'chewy/query/nodes/regexp'
 require 'chewy/query/nodes/equal'
 require 'chewy/query/nodes/query'
 require 'chewy/query/nodes/script'
+require 'chewy/query/nodes/has_child'
+require 'chewy/query/nodes/has_parent'
+require 'chewy/query/nodes/match_all'
 
 module Chewy
   class Query
@@ -24,10 +27,10 @@ module Chewy
     #   UsersIndex.filter{ (article.title =~ /Honey/) & (age < 42) & !rate }
     #
     #
-    class Context
-      def initialize &block
+    class Filters
+      def initialize outer = nil, &block
         @block = block
-        @outer = eval('self', block.binding)
+        @outer = outer || eval('self', block.binding)
       end
 
       # Outer scope call
@@ -123,10 +126,10 @@ module Chewy
       # Bool filter chainable methods
       # Used to create bool query. Nodes are passed as arguments.
       #
-      #  UsersIndex.filter{ must(age < 42, name == 'Name') }
-      #  UsersIndex.filter{ should(age < 42, name == 'Name') }
-      #  UsersIndex.filter{ must(age < 42).should(name == 'Name1', name == 'Name2') }
-      #  UsersIndex.filter{ should_not(age >= 42).must(name == 'Name1') }
+      #   UsersIndex.filter{ must(age < 42, name == 'Name') }
+      #   UsersIndex.filter{ should(age < 42, name == 'Name') }
+      #   UsersIndex.filter{ must(age < 42).should(name == 'Name1', name == 'Name2') }
+      #   UsersIndex.filter{ should_not(age >= 42).must(name == 'Name1') }
       #
       %w(must must_not should).each do |method|
         define_method method do |*exprs|
@@ -134,6 +137,56 @@ module Chewy
         end
       end
 
+      # Initializes has_child filter.
+      # Chainable interface acts the same as main query interface. You can pass plain
+      # filters or plain queries or filter with DSL block.
+      #
+      #   UsersIndex.filter{ has_child('user').filter(term: {role: 'Admin'}) }
+      #   UsersIndex.filter{ has_child('user').filter{ role == 'Admin' } }
+      #   UsersIndex.filter{ has_child('user').query(match: {name: 'borogoves'}) }
+      #
+      # Filters and queries might be combined and filter_mode and query_mode are configurable:
+      #
+      #   UsersIndex.filter do
+      #     has_child('user')
+      #       .filter{ name: 'Peter' }
+      #       .query(match: {name: 'Peter'})
+      #       .filter{ age > 42 }
+      #       .filter_mode(:or)
+      #   end
+      #
+      def has_child type
+        Nodes::HasChild.new(type, @outer)
+      end
+
+      # Initializes has_parent filter.
+      # Chainable interface acts the same as main query interface. You can pass plain
+      # filters or plain queries or filter with DSL block.
+      #
+      #   UsersIndex.filter{ has_parent('user').filter(term: {role: 'Admin'}) }
+      #   UsersIndex.filter{ has_parent('user').filter{ role == 'Admin' } }
+      #   UsersIndex.filter{ has_parent('user').query(match: {name: 'borogoves'}) }
+      #
+      # Filters and queries might be combined and filter_mode and query_mode are configurable:
+      #
+      #   UsersIndex.filter do
+      #     has_parent('user')
+      #       .filter{ name: 'Peter' }
+      #       .query(match: {name: 'Peter'})
+      #       .filter{ age > 42 }
+      #       .filter_mode(:or)
+      #   end
+      #
+      def has_parent type
+        Nodes::HasParent.new(type, @outer)
+      end
+
+      # Just simple match_all filter.
+      #
+      def match_all
+        Nodes::MatchAll.new
+      end
+
       # Creates field or exists node
       # Additional options for further expression might be passed as hash
       #