indices 0.0.1

data/lib/indices/collection.rb

@@ -0,0 +1,195 @@
+module Indices
+  class Collection
+    include Enumerable
+
+    delegate :model, to: :index
+    delegate :model_name, to: :model
+    delegate :each, :map, :size, :length, :count, :[], :to_a, to: :records
+
+    alias_method :to_ary, :to_a
+
+    def initialize(index, *args, &block)
+      @loaded = false
+      @index = index
+      @options = args.extract_options!
+      @args = args
+      @block = block
+    end
+
+    def page(number, options={})
+      length = (fetch_option(options, :length) || 10)
+      padding = (fetch_option(options, :padding) || 0)
+      current_page = [number.to_i, 1].max
+      values = Module.new do
+        define_method :page_length do
+          length
+        end
+        define_method :padding do
+          padding
+        end
+        define_method :current_page do
+          current_page
+        end
+      end
+      overrides = {
+        from: ((length * (current_page - 1)) + padding),
+        size: length
+      }
+      %i(with without).each do |name|
+        if options.has_key?(name)
+          overrides[name] = options[name]
+        end
+      end
+      chain Pagination, values, overrides
+    end
+
+    def order(options)
+      mappings = Indices.configuration.mappings
+      sort = []
+      options.each do |property, direction|
+        if block = Indices.configuration.computed_sorts[property]
+          sort << Dsl::Api.new(direction, &block).to_h
+        elsif property == :id
+          sort << { _uid: { order: direction } }
+        elsif mappings.has_key?(property) && mappings[property][:type] == 'string'
+          sort << { "#{property}.raw" => { order: direction } }
+        end
+      end
+      if sort.any?
+        chain sort: sort
+      else
+        chain
+      end
+    end
+
+    def response
+      if @loaded == true
+        @response
+      else
+        @loaded = true
+        @response = index.raw_search(query)
+      end
+    end
+
+    def query
+      @query ||= begin
+        pagination = options.slice(:from, :size, :sort)
+        without_ids = fetch_ids(options[:without])
+        body = Dsl::Search.new(args.append(options), &block).to_h[:query]
+        request = Dsl::Search.new do
+          if without_ids.any?
+            query do
+              filtered do
+                filter do
+                  bool do
+                    must_not do
+                      without_ids.each do |id|
+                        term do
+                          _id id
+                        end
+                      end
+                    end
+                  end
+                end
+                query body
+              end
+            end
+          else
+            query body
+          end
+          %i(from size).each do |option|
+            if pagination.has_key?(option)
+              send option, pagination[option]
+            end
+          end
+          if pagination.has_key?(:sort)
+            sort pagination[:sort]
+          else
+            sort do
+              _uid do
+                order 'desc'
+              end
+            end
+          end
+        end
+        request.to_h
+      end
+    end
+
+    private
+
+    attr_reader :index, :args, :options, :block
+
+    def records
+      @records ||= begin
+        if missing_ids.any?
+          last_index = -(missing_ids.length + 1)
+          ids = (missing_ids.sort.reverse + hit_ids.to(last_index))
+        else
+          ids = hit_ids
+        end
+        index.model.includes(includes).where(id: ids).sort do |a,b|
+          ids.index(a.id) <=> ids.index(b.id)
+        end
+      end
+    end
+
+    def with_ids
+      @with_ids ||= fetch_ids(options[:with])
+    end
+
+    def hit_ids
+      @hit_ids ||= response['hits']['hits'].map{ |hit| hit['_id'].to_i }
+    end
+
+    def missing_ids
+      @missing_ids ||= (with_ids - hit_ids)
+    end
+
+    def includes
+      @inclues ||= begin
+        if options.has_key?(:includes)
+          Array options[:includes]
+        else
+          []
+        end
+      end
+    end
+
+    def fetch_option(options, name)
+      options[name] || begin
+        if Rails.configuration.cache_classes == false
+          Rails.application.eager_load!
+        end
+        if defined?(Pagers)
+          Pagers.config[name]
+        end
+      end
+    end
+
+    def fetch_ids(source)
+      case source
+      when Fixnum,String
+        [source.to_i]
+      when ActiveRecord::Base
+        [source.id]
+      when ActiveRecord::Relation
+        source.ids
+      when Array
+        source.map{ |value| fetch_ids(value) }.flatten
+      else
+        []
+      end
+    end
+
+    def chain(*extensions)
+      overrides = extensions.extract_options!
+      Collection.new(index, *args.append(options.merge(overrides)), &block).tap do |collection|
+        extensions.each do |extension|
+          collection.extend extension
+        end
+      end
+    end
+
+  end
+end

data/lib/indices/concern.rb

@@ -0,0 +1,23 @@
+module Indices
+  module Concern
+    extend ActiveSupport::Concern
+
+    included do
+      after_commit :index, on: :create
+      after_commit :reindex, on: :update
+      after_commit :unindex, on: :destroy
+    end
+
+    %i(index reindex unindex).each do |name|
+      define_method name do
+        self.class.index.send name, self
+      end
+    end
+
+    module ClassMethods
+
+      delegate :search, to: :index
+
+    end
+  end
+end

data/lib/indices/configuration.rb

@@ -0,0 +1,39 @@
+module Indices
+  class Configuration
+
+    attr_accessor :hosts, :log, :trace
+
+    def computed_sorts
+      @computed_sorts ||= {}
+    end
+
+    def mappings(&block)
+      if block_given?
+        @mappings = Dsl::Mappings.new(&block).to_h
+      else
+        @mappings
+      end
+    end
+
+    def analysis(&block)
+      if block_given?
+        @analysis = { analysis: Dsl::Api.new(&block).to_h }
+      else
+        @analysis
+      end
+    end
+
+    def suggestions(&block)
+      if block_given?
+        @suggestions = block
+      else
+        @suggestions
+      end
+    end
+
+    def add_computed_sort(name, &block)
+      self.computed_sorts[name] = block
+    end
+
+  end
+end

data/lib/indices/dsl/api.rb

@@ -0,0 +1,85 @@
+module Indices
+  module Dsl
+    class Api
+
+      def initialize(args=[], parent={}, &block)
+        @args = args
+        @parent = parent
+        instance_exec *args, &block
+      end
+
+      def method_missing(name, *args, &block)
+        options = args.extract_options!
+        name = name.to_sym
+        if block_given?
+          child = add_block(name, args, options)
+          continue child, &block
+        elsif args.size > 0
+          add_argument name, args, options
+        elsif options.any?
+          add_options name, options
+        else
+          add_empty name
+        end
+      end
+
+      def to_h
+        @parent
+      end
+
+      private
+
+      def add_block(name, args, options)
+        case @parent
+        when Array
+          item = options.merge(name => {})
+          @parent << item
+          child = item[name]
+        when Hash
+          if @parent.has_key?(name)
+            child = @parent[name].merge!(options)
+          else
+            child = @parent[name] = {}
+          end
+        end
+        if args.any?
+          child[args.first.to_sym] = {}
+        else
+          child
+        end
+      end
+
+      def add_argument(name, args, options)
+        @parent[name] = args.first
+      end
+
+      def add_options(name, options)
+        options.symbolize_keys!
+        case @parent
+        when Array
+          @parent << { name => options }
+        when Hash
+          if @parent.has_key?(name)
+            @parent[name].merge! options
+          else
+            @parent[name] = options
+          end
+        end
+      end
+
+      def add_empty(name)
+        case @parent
+        when Array
+          @parent << { name => {} }
+        when Hash
+          @parent[name] = {}
+        end
+      end
+
+      def continue(child, &block)
+        self.class.new @args, child, &block
+      end
+
+    end
+  end
+end

data/lib/indices/dsl/mappings.rb

@@ -0,0 +1,14 @@
+module Indices
+  module Dsl
+    class Mappings < Api
+
+      def properties(*names)
+        @parent[:properties] ||= {}
+        names.each do |name|
+          @parent[:properties][name] = Indices.configuration.mappings[name]
+        end
+      end
+
+    end
+  end
+end

data/lib/indices/dsl/search.rb

@@ -0,0 +1,25 @@
+module Indices
+  module Dsl
+    class Search < Api
+
+      private
+
+      def add_block(name, args, options)
+        if %i(functions must must_not should).include?(name)
+          @parent[name] = []
+        else
+          super
+        end
+      end
+
+      def add_argument(name, args, options)
+        if name == :query && args.first.is_a?(Symbol)
+          @parent[name] = Indices[args.first].search(options).query[:query]
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/indices/dsl/serializer.rb

@@ -0,0 +1,17 @@
+module Indices
+  module Dsl
+    class Serializer < Api
+
+      def set(object, *names)
+        names.each do |name|
+          send name, object.send(name)
+        end
+      end
+
+      def transliterate(value)
+        ActiveSupport::Inflector.transliterate value
+      end
+
+    end
+  end
+end

data/lib/indices/index.rb

@@ -0,0 +1,149 @@
+module Indices
+  class Index
+    include Comparable
+
+    attr_reader :name, :type, :options
+
+    def initialize(name, options={})
+      @name = name
+      @type = @name.to_s.singularize
+      @options = options
+      make_indexable
+    end
+
+    def mappings
+      @mappings ||= Dsl::Mappings.new(&options[:mappings]).to_h
+    end
+
+    def model
+      (options[:class_name] || type.classify).constantize
+    end
+
+    def has_parent?
+      mappings.has_key? :_parent
+    end
+
+    def <=>(other)
+      if has_parent? && other.has_parent?
+        0
+      elsif other.has_parent?
+        1
+      else
+        -1
+      end
+    end
+
+    def any?(*args)
+      search(*args).count > 0
+    end
+
+    def none?(*args)
+      !any?(*args)
+    end
+
+    def search(*args)
+      Collection.new self, *args, &options[:search]
+    end
+
+    def raw_search(query)
+      client.search(
+        index: namespace,
+        type: type,
+        body: query
+      )
+    end
+
+    def exists?(record)
+      client.exists?(
+        with_parent(
+          record,
+          index: namespace,
+          type: type,
+          id: record.id
+        )
+      )
+    end
+
+    def index(record)
+      client.create(
+        with_parent(
+          record,
+          index: namespace,
+          type: type,
+          id: record.id,
+          body: serialize(record)
+        )
+      )
+    end
+
+    def reindex(record)
+      client.bulk(
+        index: namespace,
+        type: type,
+        body: [
+          { delete: with_parent(record, _id: record.id) },
+          { index: with_parent(record, _id: record.id, data: serialize(record)) }
+        ]
+      )
+    end
+
+    def unindex(record)
+      client.delete(
+        with_parent(
+          record,
+          index: namespace,
+          type: type,
+          id: record.id
+        )
+      )
+    end
+
+    def build
+      client.indices.put_mapping(
+        index: namespace,
+        type: type,
+        body: mappings
+      )
+      model.find_in_batches do |records|
+        client.bulk(
+          index: namespace,
+          type: type,
+          body: records.map do |record|
+            { index: with_parent(record, _id: record.id, data: serialize(record)) }
+          end
+        )
+      end
+    end
+
+    private
+
+    %i(client namespace).each do |name|
+      define_method name do
+        Indices.send name
+      end
+    end
+
+    def with_parent(record, hash)
+      if has_parent?
+        hash.merge parent: record.send("#{mappings[:_parent][:type].singularize}_id")
+      else
+        hash
+      end
+    end
+
+    def serialize(record)
+      Dsl::Serializer.new(record, &options[:serializer]).to_h
+    end
+
+    def make_indexable
+      index = self
+      model.class_eval do
+        include Indices::Concern
+        define_singleton_method :index do
+          index
+        end
+      end
+    end
+
+  end
+end