chewy 0.0.1

data/lib/chewy/fields/base.rb

@@ -0,0 +1,49 @@
+module Chewy
+  module Fields
+    class Base
+      attr_reader :name, :options, :value
+
+      def initialize(name, options = {})
+        @name, @options, @nested = name.to_sym, options, {}
+        @value = @options.delete(:value)
+      end
+
+      def multi_field?
+        @options[:type] == 'multi_field'
+      end
+
+      def compose(object)
+        result = value ? value.call(object) : object.send(name)
+
+        result = if result.is_a?(Enumerable)
+          result.map { |object| nested_compose(object) }
+        else
+          nested_compose(result)
+        end if nested.any? && !multi_field?
+
+        {name => result.as_json}
+      end
+
+      def nested(field = nil)
+        if field
+          @nested[field.name] = field
+        else
+          @nested
+        end
+      end
+
+      def mappings_hash
+        subfields = nested.any? ? {
+          (multi_field? ? :fields : :properties) => nested.values.map(&:mappings_hash).inject(:merge)
+        } : {}
+        {name => options.merge(subfields)}
+      end
+
+      private
+
+      def nested_compose(value)
+        nested.values.map { |field| field.compose(value) }.inject(:merge)
+      end
+    end
+  end
+end

data/lib/chewy/fields/default.rb

@@ -0,0 +1,10 @@
+module Chewy
+  module Fields
+    class Default < Chewy::Fields::Base
+      def initialize(name, options = {})
+        options.reverse_merge!(type: 'string')
+        super(name, options)
+      end
+    end
+  end
+end

data/lib/chewy/fields/root.rb

@@ -0,0 +1,10 @@
+module Chewy
+  module Fields
+    class Root < Chewy::Fields::Base
+      def initialize(name, options = {})
+        options.reverse_merge!(value: ->(_){_})
+        super(name, options)
+      end
+    end
+  end
+end

data/lib/chewy/index.rb

@@ -0,0 +1,71 @@
+require 'chewy/index/actions'
+require 'chewy/index/client'
+require 'chewy/index/search'
+
+module Chewy
+  class Index
+    include Actions
+    include Client
+    include Search
+
+    class_attribute :types
+    self.types = {}
+
+    class_attribute :_settings
+    self._settings = {}
+
+    def self.define_type(name_or_scope, &block)
+      type_class = Chewy::Type.new(self, name_or_scope, &block)
+      self.types = types.merge(type_class.type_name => type_class)
+
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{type_class.type_name}
+          types['#{type_class.type_name}']
+        end
+      RUBY
+    end
+
+    def self.settings(params)
+      self._settings = params
+    end
+
+    def self.index_name(suggest = nil)
+      if suggest
+        @index_name = suggest.to_s
+      else
+        @index_name ||= (name.gsub(/Index\Z/, '').demodulize.underscore if name)
+      end
+      @index_name or raise UndefinedIndex
+    end
+
+    def self.settings_hash
+      _settings.present? ? {settings: _settings} : {}
+    end
+
+    def self.mappings_hash
+      mappings = types.values.map(&:mappings_hash).inject(:merge)
+      mappings.present? ? {mappings: mappings} : {}
+    end
+
+    def self.index_params
+      [settings_hash, mappings_hash].inject(:merge)
+    end
+
+    def self.search_index
+      self
+    end
+
+    def self.search_type
+      types.keys
+    end
+
+    def self.import
+      types.values.all? { |t| t.import }
+    end
+
+    def self.reset
+      index_purge!
+      import
+    end
+  end
+end

data/lib/chewy/index/actions.rb

@@ -0,0 +1,43 @@
+module Chewy
+  class Index
+    module Actions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def index_exists?
+          client.indices.exists(index: index_name)
+        end
+
+        def index_create
+          index_create!
+        rescue Elasticsearch::Transport::Transport::Errors::BadRequest
+          false
+        end
+
+        def index_create!
+          client.indices.create(index: index_name, body: index_params)
+        end
+
+        def index_delete
+          index_delete!
+        rescue Elasticsearch::Transport::Transport::Errors::NotFound
+          false
+        end
+
+        def index_delete!
+          client.indices.delete(index: index_name)
+        end
+
+        def index_purge
+          index_delete
+          index_create
+        end
+
+        def index_purge!
+          index_delete
+          index_create!
+        end
+      end
+    end
+  end
+end

data/lib/chewy/index/client.rb

@@ -0,0 +1,13 @@
+module Chewy
+  class Index
+    module Client
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def client
+          Thread.current[:chewy_client] ||= ::Elasticsearch::Client.new Chewy.client_options
+        end
+      end
+    end
+  end
+end

data/lib/chewy/index/search.rb

@@ -0,0 +1,26 @@
+module Chewy
+  class Index
+    module Search
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def search
+          Chewy::Query.new(search_index, type: search_type)
+        end
+
+        def search_string query, options = {}
+          options = options.merge(index: search_index.index_name, type: search_type, q: query)
+          client.search(options)
+        end
+
+        def search_index
+          raise NotImplementedError
+        end
+
+        def search_type
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/chewy/query.rb

@@ -0,0 +1,141 @@
+require 'chewy/query/criteria'
+require 'chewy/query/loading'
+require 'chewy/query/pagination'
+
+module Chewy
+  class Query
+    include Enumerable
+    include Loading
+    include Pagination
+
+    DEFAULT_OPTIONS = {}
+
+    delegate :each, to: :_results
+    alias_method :to_ary, :to_a
+
+    attr_reader :index, :options, :criteria
+
+    def initialize(index, options = {})
+      @index, @options = index, DEFAULT_OPTIONS.merge(options)
+      @criteria = Criteria.new
+      reset
+    end
+
+    def ==(other)
+      if other.is_a?(self.class)
+        other.criteria == criteria
+      else
+        to_a == other
+      end
+    end
+
+    def explain(value = nil)
+      chain { criteria.update_search explain: (value.nil? ? true : value) }
+    end
+
+    def limit(value)
+      chain { criteria.update_search size: Integer(value) }
+    end
+
+    def offset(value)
+      chain { criteria.update_search from: Integer(value) }
+    end
+
+    def query(params)
+      chain { criteria.update_query params }
+    end
+
+    def facets(params)
+      chain { criteria.update_facets params }
+    end
+
+    def filter(params)
+      chain { criteria.update_filters params }
+    end
+
+    def order(*params)
+      chain { criteria.update_sort params }
+    end
+
+    def reorder(*params)
+      chain { criteria.update_sort params, purge: true }
+    end
+
+    def only(*params)
+      chain { criteria.update_fields params }
+    end
+
+  protected
+
+    def initialize_clone(other)
+      @criteria = other.criteria.clone
+      reset
+    end
+
+  private
+
+    def chain &block
+      clone.tap { |q| q.instance_eval(&block) }
+    end
+
+    def reset
+      @_response, @_results = nil
+    end
+
+    def types
+      @types ||= Array.wrap(options[:type] || options[:types])
+    end
+
+    def _filters
+      if criteria.filters.many?
+        {and: criteria.filters}
+      else
+        criteria.filters.first
+      end
+    end
+
+    def _request_query
+      if criteria.filters?
+        {query: {
+          filtered: {
+            query: criteria.query? ? criteria.query : {match_all: {}},
+            filter: _filters
+          }
+        }}
+      elsif criteria.query?
+        {query: criteria.query}
+      else
+        {}
+      end
+    end
+
+    def _request_body
+      body = _request_query
+      body = body.merge!(facets: criteria.facets) if criteria.facets?
+      body = body.merge!(sort: criteria.sort) if criteria.sort?
+      body = body.merge!(fields: criteria.fields) if criteria.fields?
+      {body: body}
+    end
+
+    def _request_target
+      {index: index.index_name, type: types}
+    end
+
+    def _request
+      [criteria.search, _request_target, _request_body].inject(:merge)
+    end
+
+    def _response
+      @_response ||= index.client.search(_request)
+    end
+
+    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']
+        index.types[hit['_type']].new attributes
+      end
+    end
+  end
+end

data/lib/chewy/query/criteria.rb

@@ -0,0 +1,81 @@
+module Chewy
+  class Query
+    class Criteria
+      STORAGES = [:search, :query, :facets, :filters, :sort, :fields]
+
+      def ==(other)
+        storages == other.storages
+      end
+
+      def storages
+        STORAGES.map { |storage| send(storage) }
+      end
+
+      [:search, :query, :facets].each do |storage|
+        class_eval <<-METHODS, __FILE__, __LINE__ + 1
+          def #{storage}
+            @#{storage} ||= {}
+          end
+        METHODS
+      end
+
+      [:filters, :sort, :fields].each do |storage|
+        class_eval <<-METHODS, __FILE__, __LINE__ + 1
+          def #{storage}
+            @#{storage} ||= []
+          end
+        METHODS
+      end
+
+      STORAGES.each do |storage|
+        class_eval <<-METHODS, __FILE__, __LINE__ + 1
+          def #{storage}?
+            #{storage}.any?
+          end
+        METHODS
+      end
+
+      def update_search(modifer)
+        search.merge!(modifer)
+      end
+
+      def update_query(modifer)
+        query.merge!(modifer)
+      end
+
+
+      def update_facets(modifer)
+        facets.merge!(modifer)
+      end
+
+      def update_filters(modifer)
+        @filters = filters + Array.wrap(modifer).delete_if(&:blank?)
+      end
+
+      def update_sort(modifer, options = {})
+        @sort = nil if options[:purge]
+        modifer = Array.wrap(modifer).flatten.map do |element|
+          element.is_a?(Hash) ? element.map { |k, v| {k => v} } : element
+        end.flatten
+        @sort = sort + modifer
+      end
+
+      def update_fields(modifer, options = {})
+        @fields = nil if options[:purge]
+        @fields = (fields + Array.wrap(modifer).flatten.map(&:to_s).delete_if(&:blank?)).uniq
+      end
+
+    protected
+
+      def initialize_clone(other)
+        STORAGES.each do |storage|
+          value = other.send(storage)
+          if value
+            value = Marshal.load(Marshal.dump(value))
+            instance_variable_set("@#{storage}", value)
+          end
+        end
+      end
+    end
+  end
+end