eagle_search 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 95f2c540d8392becd307b86370b410a014938ad8
+  data.tar.gz: 08278f066fe793bf2d8e13bcc41830d5b19dbb6d
+SHA512:
+  metadata.gz: 0f63b0ca08028e9fd056220efa3731aaf6a902bc5152b2ec6f73887bdb1fecfc75f4e809bfd16ce5fb1846a86799cba7d2fc549be88274d30c4a20b569e1e6ed
+  data.tar.gz: b460acef98b7274ae245c4c8f75f565d07d7e710d8c1726bb35e35d0e9c80bf405f3d7c8b6e317c4cd248c0e8293dbabd42d52ededec6ff2c925679827ea534d

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/eagle_search/field.rb

@@ -0,0 +1,54 @@
+module EagleSearch
+  class Field
+    def initialize(index, column)
+      @index    = index
+      @column   = column
+    end
+
+    def mapping
+      mapping = { type: type }
+      index_settings = @index.settings
+
+      if index_settings[:unsearchable_fields] && (index_settings[:unsearchable_fields].include?(@column.name) || index_settings[:unsearchable_fields].include?(@column.name.to_sym))
+        mapping[:index] = "no"
+      else
+        if type == "string"
+          if index_settings[:exact_match_fields] && (index_settings[:exact_match_fields].include?(@column.name) || index_settings[:exact_match_fields].include?(@column.name.to_sym))
+            mapping[:index] = "not_analyzed"
+          else
+            mapping[:index] = "analyzed"
+            mapping[:analyzer] = index_settings[:language] || "english"
+            mapping[:fields] = {
+              shingle: {
+                type: "string",
+                analyzer: "eagle_search_shingle_analyzer"
+              }
+            }
+          end
+        end
+      end
+
+      mapping
+    end
+
+    private
+    def type
+      case @column.type
+      when :integer
+        if @column.limit.to_i <= 8
+          "integer"
+        else
+          "long"
+        end
+      when :date, :datetime
+        "date"
+      when :boolean
+        "boolean"
+      when :decimal, :float
+        "float"
+      else
+        "string"
+      end
+    end
+  end
+end

data/lib/eagle_search/index.rb

@@ -0,0 +1,121 @@
+require 'date'
+
+module EagleSearch
+  class Index
+    attr_reader :settings, :alias_name
+    delegate :columns, to: :klass
+
+    def initialize(klass, settings)
+      @klass = klass
+      @settings = settings
+    end
+
+    def create
+      EagleSearch.client.indices.create index: name, body: body
+    end
+
+    def delete
+      EagleSearch.client.indices.delete index: alias_name
+    end
+
+    def refresh
+      EagleSearch.client.indices.refresh index: alias_name
+    end
+
+    def info
+      EagleSearch.client.indices.get index: alias_name
+    end
+
+    def name
+      @name ||= @settings[:index_name] || "#{ alias_name }_#{ DateTime.now.strftime('%Q') }"
+    end
+
+    def alias_name
+      @alias_name ||= @settings[:index_name] || "#{ @klass.model_name.route_key.downcase }_#{ EagleSearch.env }"
+    end
+
+    def type_name
+      if @settings[:mappings]
+        @settings[:mappings].keys.first.downcase
+      else
+        @klass.model_name.param_key
+      end
+    end
+
+    def reindex
+      client = EagleSearch.client
+      begin
+        aliases = client.indices.get_alias name: alias_name
+        client.indices.delete index: aliases.keys.join(",")
+      rescue
+        #do something
+      ensure
+        create
+        bulk = []
+        @klass.all.each do |record|
+          bulk << { index: { _index: alias_name, _type: type_name, _id: record.id } }
+          bulk << record.index_data
+        end
+        client.bulk body: bulk
+      end
+    end
+
+    def mappings
+      if @settings[:mappings]
+        @settings[:mappings]
+      else
+        base_mappings = {
+          type_name => {
+            properties: {}
+          }
+        }
+
+        columns.each do |column|
+          base_mappings[type_name][:properties][column.name] = EagleSearch::Field.new(self, column).mapping
+        end
+
+        base_mappings
+      end
+    end
+
+    private
+    def body
+      body = {
+        mappings: mappings,
+        aliases: { alias_name => {} },
+        settings: {
+          analysis: analysis_settings
+        }
+      }
+      body[:settings][:number_of_shards] = 1 if EagleSearch.env == "test" || EagleSearch.env == "development"
+      body
+    end
+
+    def analysis_settings
+      {
+        filter: {
+          eagle_search_shingle_filter: {
+            type: "shingle",
+            min_shingle_size: 2,
+            max_shingle_size: 2,
+            output_unigrams: false
+          }
+        },
+        analyzer: {
+          eagle_search_shingle_analyzer: {
+            type: "custom",
+            tokenizer: "standard",
+            filter: [
+              "lowercase",
+              "eagle_search_shingle_filter"
+            ]
+          }
+        }
+      }
+    end
+
+    def klass
+      @klass
+    end
+  end
+end

data/lib/eagle_search/interpreter/filter.rb

@@ -0,0 +1,55 @@
+module EagleSearch
+  class Interpreter::Filter
+    attr_reader :payload
+
+    LOGICAL_OPERATORS = { and: :must, not: :must_not, or: :should }
+
+    def initialize(filters)
+      @filters = filters
+    end
+
+    def payload
+      @payload ||= generate_payload(@filters)
+    end
+
+    private
+    def generate_payload(filters)
+      payload = {}
+
+      filters.each do |key, value|
+        key = key.to_sym
+
+        if LOGICAL_OPERATORS.include?(key)
+          payload = { bool: { LOGICAL_OPERATORS[key] => [] } }
+
+          if value.is_a?(Array)
+            value.each { |filter| payload[:bool][LOGICAL_OPERATORS[key]] << generate_payload(filter) }
+          else
+            value.each { |field, field_value| payload[:bool][LOGICAL_OPERATORS[key]] << generate_payload({ field => field_value }) }
+          end
+        else
+          payload = elasticsearch_filter_hash(key, value)
+        end
+      end
+
+      payload
+    end
+
+    def elasticsearch_filter_hash(field, field_value)
+      case field_value
+      when Array
+        { terms: { field => field_value } }
+      when Hash
+        if field_value.keys.any? { |key| %i(lt gt lte gte).include?(key.to_sym) }
+          { range: { field => field_value } }
+        end
+      when Range
+        { range: { field => { gte: field_value.min, lte: field_value.max } } }
+      when Regexp
+        { regexp: { field => field_value.source } }
+      else
+        { term: { field => field_value } }
+      end
+    end
+  end
+end

data/lib/eagle_search/interpreter/query.rb

@@ -0,0 +1,112 @@
+module EagleSearch
+  class Interpreter::Query
+
+    def initialize(index, query, options)
+      @index = index
+      @query = query
+      @options = options
+    end
+
+    def payload
+      case @query
+      when String
+        if @query == "*"
+          { match_all: {} }
+        else
+          query_payload
+        end
+      end
+    end
+
+    private
+    def properties
+      @index.mappings[@index.type_name][:properties]
+    end
+
+    def analyzed_properties
+      properties.select { |field_name, field_hash| field_hash[:type] == "string" && field_hash[:index] == "analyzed" }
+    end
+
+    def not_analyzed_properties
+      properties.select { |field_name, field_hash| field_hash[:type] == "string" && field_hash[:index] == "not_analyzed" }
+    end
+
+    def query_payload
+      @query_payload = {}
+      build_multi_match_query
+      build_match_queries
+      build_term_queries
+      @query_payload
+    end
+
+    def build_multi_match_query
+      if analyzed_properties
+        @query_payload = {
+          bool: {
+            should: []
+          }
+        }
+
+        @query_payload[:bool][:should] << {
+          multi_match: {
+            query: @query,
+            fields: @options[:fields] || analyzed_properties.keys,
+            tie_breaker: 0.3
+          }
+        }
+      end
+    end
+
+    def build_match_queries
+      return unless analyzed_properties
+
+      match_queries = []
+      analyzed_properties.keys.each do |field_name|
+        match_queries << {
+          match: {
+            "#{ field_name }.shingle" => {
+              query: @query,
+              boost: 3
+            }
+          }
+        }
+      end
+
+      payload = {
+        bool: {
+          should: match_queries
+        }
+      }
+
+      @query_payload[:bool] ? @query_payload[:bool][:should] << payload : @query_payload[:bool][:should] = payload
+    end
+
+    def build_term_queries
+      return unless not_analyzed_properties
+
+      term_queries = []
+      not_analyzed_properties.keys.each do |field_name|
+        term_queries << {
+          term: {
+            field_name => {
+              value: @query,
+              boost: 5
+            }
+          }
+        }
+      end
+
+      payload = {
+        bool: {
+          should: term_queries
+        }
+      }
+
+      if @query_payload[:bool]
+        @query_payload[:bool][:should][1][:bool][:should] << payload
+      else
+        @query_payload = payload
+      end
+    end
+  end
+end

data/lib/eagle_search/interpreter.rb

@@ -0,0 +1,56 @@
+module EagleSearch
+  class Interpreter
+    def initialize(index, query, options)
+      @index   = index
+      @query   = query
+      @options = options
+      @options[:page] = @options[:page].to_i if @options[:page]
+      @options[:per_page] = @options[:per_page].to_i if @options[:per_page]
+    end
+
+    def payload
+      return @options[:custom_payload] if @options[:custom_payload]
+
+      payload = {
+        query: {
+          filtered: {
+            query: query_payload,
+            filter: filter_payload
+          }
+        }
+      }
+
+      payload.merge!({ sort: @options[:sort] }) if @options[:sort]
+
+      # from
+      if @options[:page] && @options[:page] > 1
+        from = (@options[:page] - 1) * (@options[:per_page] || 10)
+        payload.merge!({ from: from })
+      end
+
+      #size
+      payload.merge!({ size: @options[:per_page] }) if @options[:per_page]
+
+      payload
+    end
+
+    private
+    def query_payload
+      if @options[:custom_query]
+        @options[:custom_query]
+      else
+        EagleSearch::Interpreter::Query.new(@index, @query, @options).payload
+      end
+    end
+
+    def filter_payload
+      if @options[:filters]
+        EagleSearch::Interpreter::Filter.new(@options[:filters]).payload
+      elsif @options[:custom_filters]
+        @options[:custom_filters]
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/eagle_search/model.rb

@@ -0,0 +1,62 @@
+module EagleSearch
+  class Model
+    module ClassMethods
+      def eagle_search(settings = {})
+        @index = EagleSearch::Index.new(self, settings)
+      end
+
+      def eagle_search_index
+        @index
+      end
+
+      def create_index
+        eagle_search_index.create
+      end
+
+      def delete_index
+        eagle_search_index.delete
+      end
+
+      def refresh_index
+        eagle_search_index.refresh
+      end
+
+      def index_info
+        eagle_search_index.info
+      end
+
+      def search(term, options = {})
+        interpreter = EagleSearch::Interpreter.new(@index, term, options)
+        search_response = EagleSearch.client.search index: eagle_search_index.alias_name, body: interpreter.payload
+        EagleSearch::Response.new(self, search_response, options)
+      end
+
+      def reindex
+        eagle_search_index.reindex
+      end
+    end
+
+    module InstanceMethods
+      def reindex
+        index = self.class.eagle_search_index
+        reindex_option = index.settings[:reindex]
+
+        if reindex_option.nil? || reindex_option
+          begin
+            index.info
+          rescue Elasticsearch::Transport::Transport::Errors::NotFound
+            index.create
+          ensure
+            index.refresh
+            EagleSearch.client.index(
+              index: index.alias_name,
+              type: index.type_name,
+              id: id,
+              body: index_data
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eagle_search/response.rb

@@ -0,0 +1,44 @@
+module EagleSearch
+  class Response
+    def initialize(klass, response, options)
+      @klass    = klass
+      @response = response
+      @options  = options
+    end
+
+    def records
+      ids = hits.map { |hit| hit["_id"] }
+      #avoids n+1
+      @klass.includes(@options[:includes]) if @options[:includes]
+      @klass.where(@klass.primary_key => ids)
+    end
+
+    def each
+      if block_given?
+        records.each { |e| yield(e) }
+      else
+        records.to_enum
+      end
+    end
+
+    def total_hits
+      @response["hits"]["total"]
+    end
+
+    def hits
+      @response["hits"]["hits"]
+    end
+
+    def current_page
+      @options[:page] || 1
+    end
+
+    def total_pages
+      (total_hits / limit_value.to_f).ceil
+    end
+
+    def limit_value
+      @options[:per_page] || 25
+    end
+  end
+end

data/lib/eagle_search/version.rb

@@ -0,0 +1,3 @@
+module EagleSearch
+  VERSION = "0.1.0"
+end

data/lib/eagle_search.rb

@@ -0,0 +1,25 @@
+require "eagle_search/version"
+require "eagle_search/model"
+require "eagle_search/index"
+require "eagle_search/field"
+require "eagle_search/response"
+require "eagle_search/interpreter"
+require "eagle_search/interpreter/query"
+require "eagle_search/interpreter/filter"
+require "elasticsearch"
+
+module EagleSearch
+  def self.included(base)
+    base.extend(EagleSearch::Model::ClassMethods)
+    base.include(EagleSearch::Model::InstanceMethods)
+    base.after_commit :reindex, on: [:create, :update]
+  end
+
+  def self.client
+    @client ||= Elasticsearch::Client.new
+  end
+
+  def self.env
+    @env ||= ENV['RAILS_ENV'] || "development"
+  end
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: eagle_search
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Igor Belo
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: elasticsearch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: Rails Model integration for Elasticsearch.
+email:
+- igorcoura@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/eagle_search.rb
+- lib/eagle_search/field.rb
+- lib/eagle_search/index.rb
+- lib/eagle_search/interpreter.rb
+- lib/eagle_search/interpreter/filter.rb
+- lib/eagle_search/interpreter/query.rb
+- lib/eagle_search/model.rb
+- lib/eagle_search/response.rb
+- lib/eagle_search/version.rb
+homepage: https://github.com/igorbelo/eagle_search
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Rails Model integration for Elasticsearch.
+test_files: []