indexes 4.0.0.2 → 4.0.0.3

data/Rakefile

@@ -1,19 +0,0 @@
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
-end
-
-Bundler::GemHelper.install_tasks
-
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-  t.warning = false
-end
-
-task default: :test

data/lib/generators/index/index_generator.rb

@@ -1,15 +0,0 @@
-require 'rails/generators'
-
-module Indexes
-  module Generators
-    class IndexGenerator < ::Rails::Generators::NamedBase
-
-      source_root File.expand_path('../templates', __FILE__)
-
-      def create_index_file
-        template 'index.rb', "app/indexes/#{table_name}_index.rb"
-      end
-
-    end
-  end
-end

data/lib/generators/index/templates/index.rb

@@ -1,12 +0,0 @@
-Indexes.define :<%= table_name %> do
-
-  mappings do
-  end
-
-  serialization do |record|
-  end
-
-  search do |*args|
-  end
-
-end

data/lib/generators/indexes/install/install_generator.rb

@@ -1,15 +0,0 @@
-require 'rails/generators'
-
-module Indexes
-  module Generators
-    class InstallGenerator < ::Rails::Generators::Base
-
-      source_root File.expand_path('../templates', __FILE__)
-
-      def create_initializer_file
-        copy_file 'initializer.rb', 'config/initializers/indexes.rb'
-      end
-
-    end
-  end
-end

data/lib/generators/indexes/install/templates/initializer.rb

@@ -1,10 +0,0 @@
-Indexes.configure do |config|
-
-  config.hosts = %w(localhost:9200)
-  config.log = true
-  config.trace = true
-
-  config.mappings do
-  end
-
-end

data/lib/indexes.rb

@@ -1,85 +0,0 @@
-require 'indexes/dsl/api'
-require 'indexes/dsl/mappings'
-require 'indexes/dsl/search'
-require 'indexes/dsl/serialization'
-require 'indexes/collection'
-require 'indexes/concern'
-require 'indexes/configuration'
-require 'indexes/definitions'
-require 'indexes/index'
-require 'indexes/pagination'
-require 'indexes/proxy'
-require 'indexes/railtie'
-require 'indexes/version'
-
-module Indexes
-  class << self
-
-    delegate :any?, :none?, to: :registry
-
-    def namespace
-      "#{Rails.application.class.parent_name} #{Rails.env}".parameterize('_')
-    end
-
-    def client
-      @client ||= begin
-        require 'elasticsearch'
-        Elasticsearch::Client.new(
-          hosts: configuration.hosts,
-          log: configuration.log,
-          trace: configuration.trace
-        )
-      end
-    end
-
-    def configure
-      yield configuration
-    end
-
-    def configuration
-      @configuration ||= Configuration.new
-    end
-
-    def definitions
-      @definitions ||= Definitions.new
-    end
-
-    def define(*args, &block)
-      Proxy.new *args, &block
-    end
-
-    def build
-      unless client.indices.exists?(index: namespace)
-        client.indices.create(
-          index: namespace,
-          body: { settings: configuration.analysis }
-        )
-      end
-      definitions.each &:build
-    end
-
-    def rebuild
-      destroy
-      build
-    end
-
-    def exist?(type)
-      client.indices.exists? index: namespace, type: type
-    end
-
-    def destroy
-      if client.indices.exists?(index: namespace)
-        client.indices.delete index: namespace
-      end
-    end
-
-    def suggest(*args)
-      response = client.suggest(
-        index: namespace,
-        body: { suggestions: Dsl::Api.new(args, &configuration.suggestions).to_h }
-      )
-      response['suggestions'].first['options'].map &:symbolize_keys
-    end
-
-  end
-end

data/lib/indexes/collection.rb

@@ -1,186 +0,0 @@
-module Indexes
-  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=[], options={}, &block)
-      @loaded = false
-      @index = index
-      @args = args
-      @options = options
-      @block = block
-    end
-
-    def with(ids)
-      chain with: ids
-    end
-
-    def without(ids)
-      chain without: ids
-    end
-
-    def includes(*args)
-      chain includes: args
-    end
-
-    def page(number, options={})
-      length = page_option(options, :length, 10)
-      padding = page_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
-      chain(
-        Pagination,
-        values,
-        from: ((length * (current_page - 1)) + padding),
-        size: length
-      )
-    end
-
-    def order(options)
-      mappings = Indexes.configuration.mappings
-      values = []
-      options.each do |property, direction|
-        if block = Indexes.configuration.computed_sorts[property]
-          values << Dsl::Api.new(direction, &block).to_h
-        elsif property == :id
-          values << { _uid: { order: direction } }
-        elsif mappings.has_key?(property) && mappings[property][:type] == 'string'
-          values << { "#{property}.raw" => { order: direction } }
-        end
-      end
-      if values.any?
-        chain sort: values
-      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, &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 |name|
-            if pagination.has_key?(name)
-              send name, pagination[name]
-            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
-        hit_ids = response['hits']['hits'].map{ |hit| hit['_id'].to_i }
-        missing_ids = (fetch_ids(options[:with]) - hit_ids)
-        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
-        includes = options.fetch(:includes, [])
-        index.model.includes(includes).where(id: ids).sort do |a,b|
-          ids.index(a.id) <=> ids.index(b.id)
-        end
-      end
-    end
-
-    def page_option(source, name, default)
-      source[name] || begin
-        if Rails.configuration.cache_classes == false
-          Rails.application.eager_load!
-        end
-        if defined?(Pagers)
-          Pagers.configuration.send name
-        else
-          default
-        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 = Collection.new(index, args, options.merge(overrides), &block)
-      extensions.each do |extension|
-        collection.extend extension
-      end
-      collection
-    end
-
-  end
-end

data/lib/indexes/concern.rb

@@ -1,23 +0,0 @@
-module Indexes
-  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/indexes/configuration.rb

@@ -1,39 +0,0 @@
-module Indexes
-  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 computed_sort(name, &block)
-      self.computed_sorts[name] = block
-    end
-
-  end
-end

data/lib/indexes/definitions.rb

@@ -1,24 +0,0 @@
-module Indexes
-  class Definitions
-
-    def add(*args)
-      index = Index.new(*args)
-      registry[index.name] = index
-    end
-
-    def find(name)
-      registry[name]
-    end
-
-    def each(&block)
-      registry.values.sort.each &block
-    end
-
-    private
-
-    def registry
-      @registry ||= {}
-    end
-
-  end
-end

data/lib/indexes/dsl/api.rb

@@ -1,90 +0,0 @@
-module Indexes
-  module Dsl
-    class Api
-
-      def initialize(args=[], parent={}, &block)
-        @parent = parent
-        instance_exec *args, &block
-      end
-
-      def method_missing(name, *args, &block)
-        options = args.extract_options!
-        name = name.to_sym
-        if block_given?
-          add_block name, args, options, &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, &block)
-        case args.first
-        when String,Symbol
-          child = {}
-          node = { args.first.to_sym => child }
-        when Enumerable,ActiveRecord::Relation
-          child = node = []
-        else
-          child = node = {}
-        end
-        case @parent
-        when Array
-          @parent << options.merge(name => node)
-        when Hash
-          @parent[name] = node
-        end
-        case args.first
-        when Enumerable,ActiveRecord::Relation
-          args.first.each do |arg|
-            self.class.new [arg], child, &block
-          end
-        else
-          self.class.new [], child, &block
-        end
-      end
-
-      def add_argument(name, args, options)
-        case @parent
-        when Array
-          @parent << { name => args.first }
-        when Hash
-          @parent[name] = args.first
-        end
-      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
-
-    end
-  end
-end