indices 0.0.1 → 4.0.0.1

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/indices/index_generator.rb

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

data/lib/generators/indices/install_generator.rb

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

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

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

data/lib/generators/indices/templates/initializer.rb

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

data/lib/indices.rb

@@ -1,102 +0,0 @@
-require 'generators/indices/index_generator'
-require 'generators/indices/install_generator'
-require 'indices/dsl/api'
-require 'indices/dsl/mappings'
-require 'indices/dsl/search'
-require 'indices/dsl/serializer'
-require 'indices/concern'
-require 'indices/configuration'
-require 'indices/index'
-require 'indices/pagination'
-require 'indices/proxy'
-require 'indices/railtie'
-require 'indices/collection'
-require 'indices/version'
-
-module Indices
-  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 define(*args, &block)
-      Proxy.new *args, &block
-    end
-
-    def add(*args)
-      index = Index.new(*args)
-      registry[index.name] = index
-    end
-
-    def find(name)
-      registry[name]
-    end
-    alias_method :[], :find
-
-    def each(&block)
-      registry.values.sort.each &block
-    end
-
-    def build
-      unless client.indices.exists?(index: namespace)
-        client.indices.create(
-          index: namespace,
-          body: { settings: configuration.analysis }
-        )
-      end
-      each &:build
-    end
-
-    def exist?(type)
-      client.indices.exists? index: namespace, type: type
-    end
-
-    def rebuild
-      destroy
-      build
-    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
-
-    private
-
-    def registry
-      @registry ||= {}
-    end
-
-  end
-end

data/lib/indices/collection.rb

@@ -1,195 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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