indexers 4.1.0.0

data/lib/indexers/definitions.rb

@@ -0,0 +1,24 @@
+module Indexers
+  class Definitions
+
+    def add(*args)
+      indexer = Indexer.new(*args)
+      registry[indexer.name] = indexer
+    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/indexers/dsl/api.rb

@@ -0,0 +1,94 @@
+module Indexers
+  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|
+            continue [arg], child, &block
+          end
+        else
+          continue [], 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
+
+      def continue(args, parent, &block)
+        self.class.new args, parent, &block
+      end
+
+    end
+  end
+end

data/lib/indexers/dsl/mappings.rb

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

data/lib/indexers/dsl/search.rb

@@ -0,0 +1,29 @@
+module Indexers
+  module Dsl
+    class Search < Traitable
+
+      private
+
+      def add_block(name, args, options, &block)
+        if %i(functions must must_not should).include?(name)
+          child = []
+          @parent[name] = child
+          continue [], child, &block
+        else
+          super
+        end
+      end
+
+      def add_argument(name, args, options)
+        if name == :query && args.any?
+          indexer = Indexers.definitions.find(args.first)
+          hash = self.class.new(indexer, [options], &indexer.options[:search]).to_h
+          @parent[name] = hash[:query]
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/indexers/dsl/serialization.rb

@@ -0,0 +1,17 @@
+module Indexers
+  module Dsl
+    class Serialization < Traitable
+
+      def extract(record, *names)
+        names.each do |name|
+          send name, record.send(name)
+        end
+      end
+
+      def transliterate(value)
+        ActiveSupport::Inflector.transliterate value
+      end
+
+    end
+  end
+end

data/lib/indexers/dsl/traitable.rb

@@ -0,0 +1,38 @@
+module Indexers
+  module Dsl
+    class Traitable < Api
+
+      def initialize(indexer=nil, args=[], parent={}, binding=nil, &block)
+        @indexer = indexer
+        @binding = binding
+        @block = block
+        super args, parent, &block
+      end
+
+      def traits(*names)
+        if @indexer
+          @binding = @block.binding
+          names.each do |name|
+            instance_eval &@indexer.options[:traits][name]
+          end
+          @binding = nil
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        if args.size == 0 && !block_given? && @binding.try(:local_variable_defined?, name)
+          @binding.local_variable_get name
+        else
+          super
+        end
+      end
+
+      private
+
+      def continue(args, parent, &block)
+        self.class.new @indexer, args, parent, @binding, &block
+      end
+
+    end
+  end
+end

data/lib/indexers/extensions/active_record/base.rb

@@ -0,0 +1,20 @@
+module Indexers
+  module Extensions
+    module ActiveRecord
+      module Base
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          def inherited(subclass)
+            super
+            if File.exist?("#{Rails.root}/app/indexers/#{subclass.name.underscore}_indexer.rb")
+              subclass.include Indexers::Concern
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/indexers/indexer.rb

@@ -0,0 +1,132 @@
+module Indexers
+  class Indexer
+
+    attr_reader :name, :options
+
+    def initialize(name, options)
+      @name = name
+      @options = options
+    end
+
+    def model
+      options.fetch(:class_name, name.to_s.classify).constantize
+    end
+
+    def mappings
+      @mappings ||= Dsl::Mappings.new(&options[:mappings]).to_h
+    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(query)
+      client.search(
+        index: namespace,
+        type: name,
+        body: query
+      )
+    end
+
+    def exists?(record)
+      client.exists?(
+        with_parent(
+          record,
+          index: namespace,
+          type: name,
+          id: record.id
+        )
+      )
+    end
+
+    def index(record)
+      client.create(
+        with_parent(
+          record,
+          index: namespace,
+          type: name,
+          id: record.id,
+          body: serialize(record)
+        )
+      )
+    end
+
+    def reindex(record)
+      client.bulk(
+        index: namespace,
+        type: name,
+        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: name,
+          id: record.id
+        )
+      )
+    end
+
+    def build
+      client.indices.put_mapping(
+        index: namespace,
+        type: name,
+        body: mappings
+      )
+      model.find_in_batches do |records|
+        client.bulk(
+          index: namespace,
+          type: name,
+          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
+        Indexers.send name
+      end
+    end
+
+    def with_parent(record, hash)
+      if has_parent?
+        hash.merge parent: record.send("#{mappings[:_parent][:type]}_id")
+      else
+        hash
+      end
+    end
+
+    def serialize(record)
+      Dsl::Serialization.new(self, record, &options[:serialize]).to_h
+    end
+
+  end
+end

data/lib/indexers/pagination.rb

@@ -0,0 +1,33 @@
+module Indexers
+  module Pagination
+
+    def total_pages
+      @total_pages ||= [(total_count.to_f / page_length).ceil, 1].max
+    end
+
+    def previous_page
+      @previous_page ||= (current_page > 1 ? (current_page - 1) : nil)
+    end
+
+    def next_page
+      @next_page ||= (current_page < total_pages ? (current_page + 1) : nil)
+    end
+
+    def first_page
+      1
+    end
+
+    def last_page
+      total_pages
+    end
+
+    def out_of_bounds?
+      @out_of_bounds ||= (current_page > total_pages || current_page < first_page)
+    end
+
+    def total_count
+      @total_count ||= (response['hits']['total'].to_i - padding)
+    end
+
+  end
+end

data/lib/indexers/proxy.rb

@@ -0,0 +1,22 @@
+module Indexers
+  class Proxy
+
+    def initialize(name, options={}, &block)
+      @name = name
+      @options = options.merge(traits: {})
+      instance_eval &block
+      Indexers.definitions.add name, @options
+    end
+
+    %i(mappings serialize search).each do |name|
+      define_method name do |&block|
+        @options[name] = block
+      end
+    end
+
+    def trait(name, &block)
+      @options[:traits][name] = block
+    end
+
+  end
+end

data/lib/indexers/railtie.rb

@@ -0,0 +1,23 @@
+module Indexers
+  class Railtie < Rails::Railtie
+
+    config.before_initialize do
+      Dir["#{Rails.root}/app/indexers/**/*_indexer.rb"].each do |file|
+        load file
+      end
+    end
+
+    initializer 'indexers.active_record' do
+      ActiveSupport.on_load :active_record do
+        ::ActiveRecord::Base.include(
+          Indexers::Extensions::ActiveRecord::Base
+        )
+      end
+    end
+
+    rake_tasks do
+      load 'tasks/indexers.rake'
+    end
+
+  end
+end

data/lib/indexers/version.rb

@@ -0,0 +1,5 @@
+module Indexers
+
+  VERSION = '4.1.0.0'
+
+end

data/lib/indexers.rb

@@ -0,0 +1,82 @@
+require 'indexers/dsl/api'
+require 'indexers/dsl/mappings'
+require 'indexers/dsl/traitable'
+require 'indexers/dsl/search'
+require 'indexers/dsl/serialization'
+require 'indexers/extensions/active_record/base'
+require 'indexers/collection'
+require 'indexers/computed_sorts'
+require 'indexers/concern'
+require 'indexers/configuration'
+require 'indexers/definitions'
+require 'indexers/indexer'
+require 'indexers/pagination'
+require 'indexers/proxy'
+require 'indexers/railtie'
+require 'indexers/version'
+
+module Indexers
+  class << self
+
+    def namespace
+      "#{Rails.application.class.parent_name} #{Rails.env}".parameterize('_')
+    end
+
+    def client
+      @client ||= begin
+        require 'elasticsearch'
+        Elasticsearch::Client.new YAML.load_file("#{Rails.root}/config/elasticsearch.yml")[Rails.env]
+      end
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def computed_sorts
+      @computed_sorts ||= ComputedSorts.new
+    end
+
+    def definitions
+      @definitions ||= Definitions.new
+    end
+
+    def define(*args, &block)
+      Proxy.new *args, &block
+    end
+
+    def index
+      unless client.indices.exists?(index: namespace)
+        client.indices.create(
+          index: namespace,
+          body: { settings: configuration.analysis }
+        )
+      end
+      definitions.each &:build
+    end
+
+    def reindex
+      unindex
+      index
+    end
+
+    def unindex
+      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/tasks/indexers.rake

@@ -0,0 +1,16 @@
+namespace :indexers do
+  desc 'Index all records.'
+  task index: :environment do
+    Indexers.index
+  end
+
+  desc 'Reindex all records.'
+  task reindex: :environment do
+    Indexers.reindex
+  end
+
+  desc 'Unindex all records.'
+  task unindex: :environment do
+    Indexers.unindex
+  end
+end

data/test/dsl_test.rb

@@ -0,0 +1,127 @@
+require 'test_helper'
+
+class DslTest < ActiveSupport::TestCase
+
+  test 'search' do
+    shop = Shop.create
+    seed = rand
+    days = [1,2,3]
+    opens_at = Time.now.to_i
+    closes_at = (Time.now + 1.day).to_i
+    assert_equal(
+      {
+        query: {
+          function_score: {
+            functions: [
+              { random_score: { seed: seed } },
+              {
+                weight: 400,
+                filter: {
+                  bool: {
+                    must: [
+                      { term: {} }
+                    ]
+                  }
+                }
+              }
+            ]
+          },
+          query: {
+            filtered: {
+              filter: {
+                bool: {
+                  should: [
+                    { term: { :'schedules.days' => days } }
+                  ],
+                  must: [
+                    { range: { :'schedules.opens_at' => { lte: opens_at } } }
+                  ],
+                  must_not: [
+                    {
+                      has_parent: {
+                        type: 'products',
+                        query: {
+                          filtered: {
+                            filter: {
+                              bool: {
+                                must: [
+                                  {
+                                    term: {
+                                      _parent: shop.id
+                                    }
+                                  }
+                                ]
+                              }
+                            },
+                            query: {
+                              match_all: {}
+                            }
+                          }
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        },
+        sort: [
+          { name: 'asc' }
+        ],
+        size: {}
+      },
+      build do
+        query do
+          function_score do
+            functions do
+              random_score do
+                seed seed
+              end
+              filter weight: 400 do
+                bool do
+                  must do
+                    term
+                  end
+                end
+              end
+            end
+          end
+          query do
+            filtered do
+              filter do
+                bool do
+                  should do
+                    term 'schedules.days' => days
+                  end
+                  must do
+                    range 'schedules.opens_at' do
+                      lte opens_at
+                    end
+                  end
+                  must_not do
+                    has_parent do
+                      type 'products'
+                      query :product, shop: shop
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        sort %w(asc) do |order|
+          name order
+        end
+        size
+      end
+    )
+  end
+
+  private
+
+  def build(&block)
+    Indexers::Dsl::Search.new(&block).to_h
+  end
+
+end

data/test/dummy/Rakefile

@@ -0,0 +1,5 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+Rails.application.load_tasks