elastify 0.1.5 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f4ab502f7c03b5f8a7fa7af85d90b19aa802f4db
-  data.tar.gz: a6c9b23857f1570301e01ff350a12a898abb5720
+  metadata.gz: 0776e84590a5077aede923f0523f3565590174ee
+  data.tar.gz: db4c2697ee68585beafa19121411e802ccddb3eb
 SHA512:
-  metadata.gz: c9726dc4fc3c9ea720707d2cc456ab76cef7b8d33b633c885c8a31b4699d9f268616a92e6355bd40184c1adaff02266ae9b8dbad580a4fae92d4662cdc217c2a
-  data.tar.gz: 172f7ca92c8826728cd7bca85b3d73f4e26368d9370a15eb24da29b63be7987a4633ca22cd64b31848a98f7d23042e2da03c24c81ede762359cf4d3478f59a89
+  metadata.gz: 2187b6b1b38cb00326579c023c7e0c678cb87fb88b892315eaa961c7868ae221681aff0ca9a9796a03e2bfa0043233f990dff85043d68608b61e7e66ad027a14
+  data.tar.gz: f34de86be910ce647fd68ee355cdc4fb12ce659d8713182bd0587a84707875171e62295fd1a3a55a80708faf429695a528b415cdbf78b9e9a062e605b7d4cbb8

data/lib/elastify.rb

@@ -1,5 +1,14 @@
-require "elastify/version"
-require "elastify/active_record_extensions"
+require 'elastify/version'
+require 'elastify/errors/base'
+require 'elastify/errors/bad_request'
+require 'elastify/errors/connection'
+require 'elastify/configurators/model'
+require 'elastify/active_record_extensions'
+require 'elastify/helpers/elastic_search/connector'
+require 'elastify/helpers/elastic_search/document'
+require 'elastify/helpers/elastic_search/search_result'
+require 'elastify/helpers/elastic_search/search_result_collection'
+
 
 module Elastify
     
@@ -7,14 +16,14 @@ module Elastify
         def configure &block
             mappings = {}
             configs = OpenStruct.new({
-                base_url: "http://localhost:9200",
-                mappings_path: Rails.root.join("config/elastify/mappings")
+                base_url: 'http://localhost:9200',
+                mappings_path: Rails.root.join('config/elastify/mappings')
             })
             block.call(configs) if block_given?
             dir = configs.mappings_path
             if Dir.exist?(dir)
                 Dir.glob("#{dir}/*.json") do |file_path|
-                    mappings[File.basename(file_path, ".json")] = JSON.parse(File.read(file_path))
+                    mappings[File.basename(file_path, '.json')] = JSON.parse(File.read(file_path))
                 end
             end
             Rails.application.config.elastify = {

data/lib/elastify/active_record_extensions.rb

@@ -1,114 +1,100 @@
 require 'active_record'
 require 'backgrounded'
-require 'elastify/elastic_search_helper'
 require 'elastify'
 
-module Elastify
-    module ActiveRecordExtensions
-        extend ActiveSupport::Concern
+module Elastify::ActiveRecordExtensions
+    extend ActiveSupport::Concern
 
-        module ClassMethods
-            def elastify type, index, &block
-                include Elastify::ActiveRecordExtensions::LocalMethods
-                cattr_accessor :elastify_options, :elastify_model_block
-                attr_accessor :elastify_serialized_document
+    module ClassMethods
+        extend ActiveSupport::Concern
 
-                self.elastify_options = {
-                    base_url: Elastify.configs[:base_url],
-                    index: index,
-                    type: type,
-                    map: Elastify.mappings.symbolize_keys[type.to_sym]
-                }
+        def elastify_setup(&block)
+            include Elastify::ActiveRecordExtensions::LocalMethods
+            cattr_accessor :elastify_options
+            attr_accessor :elastify_serialized_document
+
+            config = Elastify::Configurators::Model.new
+            yield(config) if block_given?
+            self.elastify_options = {} if self.elastify_options.blank?
+            self.elastify_options[:base_url] = Elastify.configs[:base_url]
+            self.elastify_options[:index] = config.opt_index if config.opt_index.present?
+            self.elastify_options[:type] = config.opt_type if config.opt_type.present?
+            self.elastify_options[:map] = config.opt_mapping if config.opt_mapping.present?
+            self.elastify_options[:decode] = config.opt_decode if config.opt_decode.present?
+            self.elastify_options[:encode] = config.opt_encode if config.opt_encode.present?
+        end
 
-                self.elastify_options.each do |key, value|
-                    if value.blank? 
-                        raise ElastifyError, "You must specify the #{key} value"
-                    end
-                end 
+        def elastify_search(dsl: nil, scroll_timer: "1m")
+            return Elastify::Helpers::ElasticSearch::Document.new(self.elastify_options).search(dsl, scroll_timer)
+        end
 
-                if block_given?
-                    self.elastify_model_block = block
-                else 
-                    if self.respond_to?(:to_elastify)
-                        self.elastify_model_block = Proc.new { |item| next item.to_elastify }
-                    elsif self.respond_to?(:to_serial)
-                        self.elastify_model_block = Proc.new { |item| next item.to_serial }
-                    else   
-                        self.elastify_model_block = Proc.new { |item| next item.serializable_hash }
-                    end
-                end
-            end
+        def elastify_scroll(scroll_id: nil, scroll_timer: "1m")
+            return Elastify::Helpers::ElasticSearch::Document.new(self.elastify_options).scroll(scroll_id, scroll_timer)
         end
+    end
 
-        module LocalMethods
-            extend ActiveSupport::Concern
+    module LocalMethods
+        extend ActiveSupport::Concern
 
-            def elastify_create
-                run_callbacks(:elastify_sync) do 
-                    if not self.elastify_serialized_document.blank?
-                        run_callbacks(:elastify_create) do
-                            ElasticSearchHelper::Document.new(self.elastify_options).create(self.elastify_serialized_document)
-                        end
+        def elastify_create
+            run_callbacks(:elastify_sync) do
+                if not self.elastify_serialized_document.blank?
+                    run_callbacks(:elastify_create) do
+                        Elastify::Helpers::ElasticSearch::Document.new(self.class.elastify_options).create(self.elastify_serialized_document)
                     end
                 end
             end
+        end
 
-            def elastify_update
-                run_callbacks(:elastify_sync) do 
-                    if not self.elastify_serialized_document.blank?
-                        run_callbacks(:elastify_update) do
-                            ElasticSearchHelper::Document.new(self.elastify_options).update(self.elastify_serialized_document)
-                        end
+        def elastify_update
+            run_callbacks(:elastify_sync) do
+                if not self.elastify_serialized_document.blank?
+                    run_callbacks(:elastify_update) do
+                        Elastify::Helpers::ElasticSearch::Document.new(self.class.elastify_options).update(self.elastify_serialized_document)
                     end
                 end
             end
+        end
 
-            def elastify_destroy 
-                run_callbacks(:elastify_sync) do 
-                    if not self.elastify_serialized_document.blank?
-                        run_callbacks(:elastify_destroy) do
-                            ElasticSearchHelper::Document.new(self.elastify_options).destroy(self.elastify_serialized_document)
-                        end
+        def elastify_destroy
+            run_callbacks(:elastify_sync) do
+                if not self.elastify_serialized_document.blank?
+                    run_callbacks(:elastify_destroy) do
+                        Elastify::Helpers::ElasticSearch::Document.new(self.class.elastify_options).destroy(self.elastify_serialized_document)
                     end
                 end
             end
-            
-            included do
-                define_model_callbacks :elastify_create
-                define_model_callbacks :elastify_update
-                define_model_callbacks :elastify_destroy
-                define_model_callbacks :elastify_sync
-                # define_model_callbacks :elastify_serialize
+        end
 
-                after_commit on: :create do |item|
-                    item.elastify_create
-                end
+        included do
+            define_model_callbacks :elastify_create
+            define_model_callbacks :elastify_update
+            define_model_callbacks :elastify_destroy
+            define_model_callbacks :elastify_sync
+            # define_model_callbacks :elastify_serialize
 
-                after_commit on: :update do |item|
-                    item.elastify_update
-                end
+            after_commit on: :create do |item|
+                item.elastify_create
+            end
 
-                after_commit on: :destroy do |item|
-                    item.elastify_destroy
-                end
+            after_commit on: :update do |item|
+                item.elastify_update
+            end
 
-                before_elastify_sync do |item|
-                    item.elastify_serialized_document = self.elastify_model_block.call(item)
-                end
-            end 
+            after_commit on: :destroy do |item|
+                item.elastify_destroy
+            end
 
-            module ClassMethods
-                def elastify_search(dsl: nil, scroll_timer: "1m")
-                    return ElasticSearchHelper::Document.new(self.elastify_options).search(dsl, scroll_timer)
-                end
-                
-                def elastify_scroll(scroll_id: nil, scroll_timer: "1m")
-                    return ElasticSearchHelper::Document.new(self.elastify_options).scroll(scroll_id, scroll_timer)
+            before_elastify_sync do |item|
+                if self.class.elastify_options[:encode].present?
+                    encoder = self.class.elastify_options[:encode]
+                elsif self.respond_to?(:to_serial)
+                    encoder = Proc.new { |item| next item.to_serial }
+                else
+                    encoder = Proc.new { |item| next item.serializable_hash }
                 end
+                item.elastify_serialized_document = encoder.call(item)
             end
         end
-
     end
-end
-
-ActiveRecord::Base.send(:include, Elastify::ActiveRecordExtensions)
+end

data/lib/elastify/configurators/model.rb

@@ -0,0 +1,28 @@
+module Elastify
+    module Configurators
+        class Model
+
+            attr_accessor :opt_index, :opt_type, :opt_mapping, :opt_encode, :opt_decode
+
+            def index(index)
+                @opt_index = index
+            end
+
+            def type(type)
+                @opt_type = type
+            end
+
+            def mapping(&block)
+                @opt_mapping = block.call() if block_given?
+            end
+
+            def encode(&block)
+                @opt_encode = block if block_given?
+            end
+
+            def decode(&block)
+                @opt_decode = block if block_given?
+            end
+        end
+    end
+end

data/lib/elastify/errors/bad_request.rb

@@ -0,0 +1,7 @@
+module Elastify
+    module Errors
+        class BadRequest < ::Elastify::Errors::Base
+
+        end
+    end
+end

data/lib/elastify/errors/base.rb

@@ -0,0 +1,7 @@
+module Elastify
+    module Errors
+        class Base < ::StandardError
+
+        end
+    end
+end

data/lib/elastify/errors/connection.rb

@@ -0,0 +1,7 @@
+module Elastify
+    module Errors
+        class Connection < Elastify::Errors::Base
+
+        end
+    end
+end

data/lib/elastify/helpers/elastic_search/connector.rb

@@ -0,0 +1,69 @@
+module Elastify
+    module Helpers
+        module ElasticSearch
+            class Connector
+                def self.create(options, data)
+                    if data.blank?
+                        raise :elastify__create__required_data
+                    end
+                    if data[:id].blank?
+                        raise :elastify__create__required_data_id
+                    end
+                    url = "#{options[:base_url]}/#{options[:index]}/#{options[:type]}/#{data[:id]}"
+                    response = JSON.parse(RestClient.put(url, data.to_json, {}))
+                end
+                def self.update options, data
+                    if data.blank?
+                        raise :elastify__update__required_data
+                    end
+                    if data[:id].blank?
+                        raise :elastify__update__required_data_id
+                    end
+                    url = "#{options[:base_url]}/#{options[:index]}/#{options[:type]}/#{data[:id]}"
+                    response = JSON.parse(RestClient.put(url, data.to_json, {})).to_hash
+                end
+                def self.destroy options, data
+                    if data.blank?
+                        raise :elastify__delete__required_data
+                    end
+                    if data[:id].blank?
+                        raise :elastify__delete__required_data_id
+                    end
+                    url = "#{options[:base_url]}/#{options[:index]}/#{options[:type]}/#{data[:id]}"
+                    response = JSON.parse(RestClient.delete(url)).to_hash
+                end
+                def self.search options, dsl, scroll_timer
+                    if dsl.blank?
+                        raise :elastify__search__required_dsl
+                    end
+                    url = "#{options[:base_url]}/#{options[:index]}/#{options[:type]}/_search"
+                    url += "?scroll=#{scroll_timer}" if scroll_timer.present?
+                    puts url
+                    response = Elastify::Helpers::ElasticSearch::SearchResultCollection.new(RestClient.post(url, dsl.to_json, {}), options)
+                end
+                def self.scroll options, scroll_id, scroll_timer
+                    if scroll_id.blank?
+                        raise :elastify__search__required_scroll_id
+                    end
+                    url = "#{options[:base_url]}/_search/scroll"
+                    dsl = { scroll: scroll_timer, scroll_id: scroll_id }
+                    puts dsl.to_json
+                    response = Elastify::Helpers::ElasticSearch::SearchResultCollection.new(RestClient.post(url, dsl.to_json, {}), options)
+                end
+                def self.create_index options
+                    url = "#{options[:base_url]}/#{options[:index]}"
+                    response = JSON.parse(RestClient.put(url, {}.to_json, {})).to_hash
+                end
+                def self.destroy_index options
+                    url = "#{options[:base_url]}/#{options[:index]}"
+                    response = JSON.parse(RestClient.delete(url)).to_hash
+                end
+                def self.create_mapping options
+                    url = "#{options[:base_url]}/#{options[:index]}/_mappings/#{options[:type]}"
+                    puts options[:map]
+                    response = JSON.parse(RestClient.put(url, options[:map].squish, {})).to_hash
+                end
+            end
+        end
+    end
+end

data/lib/elastify/helpers/elastic_search/document.rb

@@ -0,0 +1,27 @@
+module Elastify
+    module Helpers
+        module ElasticSearch
+            class Document
+                cattr_accessor :options
+                def initialize(options = {})
+                    @options = options
+                end
+                def create(model)
+                    Connector.create(@options, model)
+                end
+                def update(model)
+                    Connector.update(@options, model)
+                end
+                def destroy(model)
+                    Connector.destroy(@options, model)
+                end
+                def search(dsl, scroll_timer = nil)
+                    Connector.search(@options, dsl, scroll_timer)
+                end
+                def scroll(scroll_id, scroll_timer = nil)
+                    Connector.scroll(@options, scroll_id, scroll_timer)
+                end
+            end
+        end
+    end
+end

data/lib/elastify/helpers/elastic_search/search_result.rb

@@ -0,0 +1,26 @@
+module Elastify
+    module Helpers
+        module ElasticSearch
+            class SearchResult
+                attr_accessor :index, :type, :id, :score, :source,
+                              :elastify_options
+
+                def initialize(elasticsearch_search_result_hit, elastify_options)
+                    @index = elasticsearch_search_result_hit["_index"]
+                    @type = elasticsearch_search_result_hit["_type"]
+                    @id = elasticsearch_search_result_hit["_id"]
+                    @source = elasticsearch_search_result_hit["_source"]
+                    @elastify_options = elastify_options
+                end
+
+                def decode
+                    data = {}
+                    if @elastify_options[:decode]
+                        data = @elastify_options[:decode].call(@source)
+                    end
+                    return data
+                end
+            end
+        end
+    end
+end

data/lib/elastify/helpers/elastic_search/search_result_collection.rb

@@ -0,0 +1,24 @@
+module Elastify
+    module Helpers
+        module ElasticSearch
+            class SearchResultCollection
+                attr_accessor :scroll_id, :took, :timed_out, :shards_total, :shards_successful, :shards_failed, :hits_total, :hits_maxscore, :hits,
+                              :elastify_options
+
+                def initialize(elasticsearch_search_result, elastify_options)
+                    esr = JSON.parse(elasticsearch_search_result)
+                    @scroll_id = esr["_scroll_id"]
+                    @took = esr["took"]
+                    @timed_out = esr["timed_out"]
+                    @shards_total = esr["_shards"]["total"]
+                    @shards_successful = esr["_shards"]["successful"]
+                    @shards_failed = esr["_shards"]["failed"]
+                    @hits_total = esr["hits"]["total"]
+                    @hits_maxscore = esr["hits"]["maxscore"]
+                    @hits = esr["hits"]["hits"].map{ |hit| Elastify::Helpers::ElasticSearch::SearchResult.new(hit, elastify_options) }
+                    @elastify_options = elastify_options
+                end
+            end
+        end
+    end
+end

data/lib/elastify/version.rb

@@ -1,3 +1,3 @@
 module Elastify
-  VERSION = "0.1.5"
+  VERSION = '0.2.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elastify
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.2
 platform: ruby
 authors:
 - Bruno Bortolotti Ribeiro
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-17 00:00:00.000000000 Z
+date: 2017-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -174,7 +174,14 @@ files:
 - elastify.gemspec
 - lib/elastify.rb
 - lib/elastify/active_record_extensions.rb
-- lib/elastify/elastic_search_helper.rb
+- lib/elastify/configurators/model.rb
+- lib/elastify/errors/bad_request.rb
+- lib/elastify/errors/base.rb
+- lib/elastify/errors/connection.rb
+- lib/elastify/helpers/elastic_search/connector.rb
+- lib/elastify/helpers/elastic_search/document.rb
+- lib/elastify/helpers/elastic_search/search_result.rb
+- lib/elastify/helpers/elastic_search/search_result_collection.rb
 - lib/elastify/version.rb
 homepage: https://github.com/brunobortolotti/elastify.git
 licenses:

data/lib/elastify/elastic_search_helper.rb

@@ -1,112 +0,0 @@
-module Elastify 
-    module ElasticSearchHelper 
-        class Document
-            cattr_accessor :options
-            def initialize options = {}
-                self.options = options
-            end
-            def create model
-                Connector.create(self.options, model)
-            end
-            def update model
-                Connector.update(self.options, model)
-            end
-            def destroy model
-                Connector.destroy(self.options, model)
-            end
-            def search dsl, scroll_timer = nil
-                Connector.search(self.options, dsl, scroll_timer)
-            end
-            def scroll scroll_id, scroll_timer = nil
-                Connector.scroll(self.options, scroll_id, scroll_timer)
-            end
-        end
-        class Connector
-            def self.create(options, data)
-                if data.blank?
-                    raise :elastify__create__required_data
-                end
-                if data[:id].blank?
-                    raise :elastify__create__required_data_id
-                end
-                url = "#{options[:base_url]}/#{options[:index]}/#{options[:type]}/#{data[:id]}"
-                response = JSON.parse(RestClient.put(url, data.to_json, {}))
-            end
-            def self.update options, data
-                if data.blank?
-                    raise :elastify__update__required_data
-                end
-                if data[:id].blank?
-                    raise :elastify__update__required_data_id
-                end
-                url = "#{options[:base_url]}/#{options[:index]}/#{options[:type]}/#{data[:id]}"
-                response = JSON.parse(RestClient.put(url, data.to_json, {})).to_hash
-            end
-            def self.destroy options, data
-                if data.blank?
-                    raise :elastify__delete__required_data
-                end
-                if data[:id].blank?
-                    raise :elastify__delete__required_data_id
-                end
-                url = "#{options[:base_url]}/#{options[:index]}/#{options[:type]}/#{data[:id]}"
-                response = JSON.parse(RestClient.delete(url)).to_hash
-            end
-            def self.search options, dsl, scroll_timer
-                if dsl.blank?
-                    raise :elastify__search__required_dsl
-                end
-                url = "#{options[:base_url]}/#{options[:index]}/#{options[:type]}/_search"
-                url += "?scroll=#{scroll_timer}" if scroll_timer.present?
-                puts url
-                response = SearchResultSet.new(RestClient.post(url, dsl.to_json, {}))
-            end
-            def self.scroll options, scroll_id, scroll_timer
-                if scroll_id.blank?
-                    raise :elastify__search__required_scroll_id
-                end
-                url = "#{options[:base_url]}/_search/scroll"
-                dsl = { scroll: scroll_timer, scroll_id: scroll_id }
-                puts dsl.to_json
-                response = SearchResultSet.new(RestClient.post(url, dsl.to_json, {}))
-            end
-            def self.create_index options
-                url = "#{options[:base_url]}/#{options[:index]}"
-                response = JSON.parse(RestClient.put(url, {}.to_json, {})).to_hash
-            end
-            def self.destroy_index options
-                url = "#{options[:base_url]}/#{options[:index]}"
-                response = JSON.parse(RestClient.delete(url)).to_hash
-            end
-            def self.create_mapping options
-                url = "#{options[:base_url]}/#{options[:index]}/_mappings/#{options[:type]}"
-                puts options[:map]
-                response = JSON.parse(RestClient.put(url, options[:map].squish, {})).to_hash
-            end
-        end
-        class SearchResultSet
-            attr_accessor :scroll_id, :took, :timed_out, :shards_total, :shards_successful, :shards_failed, :hits_total, :hits_maxscore, :hits
-            def initialize elasticsearch_search_result
-                esr = JSON.parse(elasticsearch_search_result)
-                self.scroll_id = esr["_scroll_id"]
-                self.took = esr["took"]
-                self.timed_out = esr["timed_out"]
-                self.shards_total = esr["_shards"]["total"]
-                self.shards_successful = esr["_shards"]["successful"]
-                self.shards_failed = esr["_shards"]["failed"]
-                self.hits_total = esr["hits"]["total"]
-                self.hits_maxscore = esr["hits"]["maxscore"]
-                self.hits = esr["hits"]["hits"].map{ |hit| SearchResult.new(hit) }
-            end
-        end
-        class SearchResult
-            attr_accessor :index, :type, :id, :score, :source
-            def initialize elasticsearch_search_result_hit
-                self.index = elasticsearch_search_result_hit["_index"]
-                self.type = elasticsearch_search_result_hit["_type"]
-                self.id = elasticsearch_search_result_hit["_id"]
-                self.source = elasticsearch_search_result_hit["_source"]
-            end
-        end
-    end
-end