stretchy-model 0.1.0

data/lib/stretchy/common.rb

@@ -0,0 +1,33 @@
+module Stretchy
+    module Common
+        extend ActiveSupport::Concern
+
+        def inspect
+            "#<#{self.class.name} #{attributes.map { |k,v| "#{k}: #{v.blank? ? 'nil' : v}" }.join(', ')}>"
+        end
+
+
+        class_methods do
+
+            # Set the default sort key to be used in sort operations
+            #
+            def default_sort_key(field = nil)
+                @default_sort_key = field unless field.nil?
+                @default_sort_key
+            end
+
+            def default_size(size = 10000)
+                @default_size = size
+            end
+
+            private
+
+            # Return a Relation instance to chain queries
+            #
+            def relation
+                Relation.create(self, {})
+            end
+
+        end
+    end
+end

data/lib/stretchy/delegation/delegate_cache.rb

@@ -0,0 +1,131 @@
+# TODO: Break out modules into separate files
+module Stretchy 
+  module Delegation # :nodoc:
+    module DelegateCache
+      def relation_delegate_class(klass) # :nodoc:
+        @relation_delegate_cache[klass]
+      end
+
+      def initialize_relation_delegate_cache # :nodoc:
+        @relation_delegate_cache = cache = {}
+        [
+          Stretchy::Relation,
+        ].each do |klass|
+          delegate = Class.new(klass) {
+            include ClassSpecificRelation
+          }
+          const_set klass.name.gsub("::", "_"), delegate
+          cache[klass] = delegate
+        end
+      end
+
+      def self.extended(child_class)
+        child_class.initialize_relation_delegate_cache
+        super
+      end
+    end
+
+    extend ActiveSupport::Concern
+
+    # This module creates compiled delegation methods dynamically at runtime, which makes
+    # subsequent calls to that method faster by avoiding method_missing. The delegations
+    # may vary depending on the klass of a relation, so we create a subclass of Relation
+    # for each different klass, and the delegations are compiled into that subclass only.
+
+    BLACKLISTED_ARRAY_METHODS = [
+      :compact!, :flatten!, :reject!, :reverse!, :rotate!, :map!,
+      :shuffle!, :slice!, :sort!, :sort_by!, :delete_if,
+      :keep_if, :pop, :shift, :delete_at, :compact, :select!,
+    ].to_set # :nodoc:
+
+    delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, :join, to: :to_a
+    delegate :inner_hits, :highlights, :total, to: :to_a
+    delegate :aggregations, to: :response
+    
+
+    delegate :mapping, :index_name, :document_type, :to => :klass
+
+    module ClassSpecificRelation # :nodoc:
+      extend ActiveSupport::Concern
+
+      included do
+        @delegation_mutex = Mutex.new
+      end
+
+      module ClassMethods # :nodoc:
+        def name
+          superclass.name
+        end
+
+        def delegate_to_scoped_klass(method)
+          @delegation_mutex.synchronize do
+            return if method_defined?(method)
+
+            if method.to_s =~ /\A[a-zA-Z_]\w*[!?]?\z/
+              module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                  def #{method}(*args, &block)
+                    scoping { @klass.#{method}(*args, &block) }
+                  end
+                RUBY
+            else
+              define_method method do |*args, &block|
+                scoping { @klass.public_send(method, *args, &block) }
+              end
+            end
+          end
+        end
+
+        def delegate(method, opts = {})
+          @delegation_mutex.synchronize do
+            return if method_defined?(method)
+            super
+          end
+        end
+      end
+
+      protected
+
+      def method_missing(method, *args, &block)
+        if @klass.respond_to?(method)
+          self.class.delegate_to_scoped_klass(method)
+          scoping { @klass.public_send(method, *args, &block) }
+        else
+          super
+        end
+      end
+    end
+
+    module ClassMethods # :nodoc:
+      def create(klass, *args)
+        relation_class_for(klass).new(klass, *args)
+      end
+
+      private
+
+      def relation_class_for(klass)
+        klass.relation_delegate_class(self)
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      super || @klass.respond_to?(method, include_private) ||
+        array_delegable?(method)
+    end
+
+    protected
+
+    def array_delegable?(method)
+      Array.method_defined?(method) && BLACKLISTED_ARRAY_METHODS.exclude?(method)
+    end
+
+    def method_missing(method, *args, &block)
+      if @klass.respond_to?(method)
+        scoping { @klass.public_send(method, *args, &block) }
+      elsif array_delegable?(method)
+        to_a.public_send(method, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/stretchy/delegation/gateway_delegation.rb

@@ -0,0 +1,43 @@
+module Stretchy
+  module Delegation
+    module GatewayDelegation
+      delegate :settings,
+                :mappings,
+                :mapping,
+                :document_type,
+                :document_type=,
+                :index_name,
+                :index_name=,
+                :search,
+                :find,
+                :exists?,
+                :create_index!,
+                :delete_index!,
+                :index_exists?,
+                :refresh_index!,
+                :count,
+        to: :gateway
+
+      include Rails::Instrumentation::Publishers::Record
+
+      def index_name(name=nil, &block)
+          if name || block_given?
+            return (@index_name = name || block)
+          end
+
+          if @index_name.respond_to?(:call)
+            @index_name.call
+          else
+            @index_name || base_class.model_name.collection
+          end
+      end
+
+      def gateway(&block)
+          @gateway ||= Stretchy::Repository.create(index_name: index_name, klass: base_class)
+          block.arity < 1 ? @gateway.instance_eval(&block) : block.call(@gateway) if block_given?
+          @gateway
+      end
+
+    end
+  end
+end

data/lib/stretchy/indexing/bulk.rb

@@ -0,0 +1,48 @@
+module Stretchy
+    module Indexing
+        module Bulk
+            extend ActiveSupport::Concern
+
+            class_methods do
+
+                def bulk(records)
+                    self.gateway.client.bulk body: records
+                end
+
+                # bulk_in_batches(records, size: 100) do |batch|
+                #   # do something with the batch
+                #   batch.each { |record| record.to_bulk(method)}
+                # end
+                def bulk_in_batches(records, size: 1000)
+                    bulk_results = records.each_slice(size).map do |batch|
+                        yield batch if block_given?
+                        bulk(batch)
+                    end
+                    self.refresh_index!
+                    bulk_results
+                end
+
+
+            end
+
+            # TODO: May only be needed for associations
+            def update_all(**attributes)
+                # self.class.bulk_in_batches(self.all, size: 1000, method: :update) do |batch|
+                #     batch.map! { |record| attributes.each { |key, value| record.send("#{key}=", value) } }
+                # end
+            end
+
+            def to_bulk(method = :index)
+                case method
+                when :index
+                  { index: { _index: self.class.index_name, data: self.as_json.except(:id) } }
+                when :delete
+                  { delete: { _index: self.class.index_name, _id: self.id } }
+                when :update
+                  { update: { _index: self.class.index_name, _id: self.id, data: { doc: self.as_json.except(:id) } } }
+                end
+            end
+
+        end
+    end
+end

data/lib/stretchy/model/callbacks.rb

@@ -0,0 +1,31 @@
+module Stretchy
+    module Model
+      module Callbacks
+
+        extend ActiveSupport::Concern
+
+
+        included do
+          mattr_accessor :_circuit_breaker_callbacks, default: []
+
+          define_model_callbacks :create, :save, :update, :destroy
+          define_model_callbacks :find, :touch, only: :after
+        end
+
+        class_methods do
+
+          def query_must_have(*args, &block)
+            options = args.extract_options!
+
+            cb = block_given? ? block : options[:validate_with]
+
+            options[:message] = "does not exist in #{options[:in]}." unless options.has_key? :message
+
+            _circuit_breaker_callbacks << {name: args.first, options: options, callback: cb}
+
+          end
+        end
+
+      end
+    end
+end

data/lib/stretchy/model/serialization.rb

@@ -0,0 +1,20 @@
+module Stretchy
+    module Model 
+        module Serialization
+            extend ActiveSupport::Concern
+
+            def serialize(document)
+                Hash[document.to_hash.map { |k,v|  v.upcase! if k == :title; [k,v] }]
+            end
+
+            def deserialize(document)
+                attribs = ActiveSupport::HashWithIndifferentAccess.new(document['_source']).deep_symbolize_keys
+                _id = __get_id_from_document(document)
+                attribs[:id] = _id if _id
+                klass.new attribs
+            end
+
+        end
+    end
+end
+    

data/lib/stretchy/null_relation.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Stretchy
+  module NullRelation # :nodoc:
+    def pluck(*column_names)
+      []
+    end
+
+    def delete_all
+      0
+    end
+
+    def update_all(_updates)
+      0
+    end
+
+    def delete(_id_or_array)
+      0
+    end
+
+    def empty?
+      true
+    end
+
+    def none?
+      true
+    end
+
+    def any?
+      false
+    end
+
+    def one?
+      false
+    end
+
+    def many?
+      false
+    end
+
+    def exists?(_conditions = :none)
+      false
+    end
+
+    def or(other)
+      other.spawn
+    end
+
+    def exec_queries
+      @records = OpenStruct.new(klass: NullRelation, total: 0, results: []).freeze
+    end
+  end
+end

data/lib/stretchy/persistence.rb

@@ -0,0 +1,43 @@
+module Stretchy
+    module Persistence
+        extend ActiveSupport::Concern
+
+        class_methods do
+            def create(*args)
+                self.new(*args).save
+            end
+        end
+
+        def save
+            run_callbacks :save do
+                if new_record?
+                    run_callbacks :create do
+                        response = self.class.gateway.save(self.attributes)
+                        self.id = response['_id']
+                    end
+                else
+                    self.class.gateway.save(self.attributes)
+                end
+                self
+            end
+        end
+
+        def destroy
+            run_callbacks :destroy do
+                delete
+            end
+        end
+
+        def delete
+            self.class.gateway.delete(self.id)["result"] == 'deleted'
+        end
+
+        def update(*args)
+            run_callbacks :update do
+                self.assign_attributes(*args)
+                self.save
+            end
+        end
+
+    end
+end

data/lib/stretchy/querying.rb

@@ -0,0 +1,20 @@
+module Stretchy
+  module Querying
+    delegate :first, :first!, :last, :last!, :exists?, :has_field, :any?, :many?, to: :all
+    delegate :order, :limit, :size, :sort, :where, :rewhere, :eager_load, :includes,  :create_with, :none, :unscope, to: :all
+    delegate :or_filter, :filter, :fields, :source, :highlight, :aggregation, to: :all
+    delegate :skip_callbacks, :routing, to: :all
+    delegate :search_options, :routing, to: :all
+    delegate :must, :must_not, :should, :where_not, :query_string, to: :all
+
+    def fetch_results(es)
+      unless es.count?
+        base_class.search(es.to_elastic, es.search_options)
+      else
+        base_class.count(es.to_elastic, es.search_options)
+      end
+    end
+
+
+  end
+end

data/lib/stretchy/record.rb

@@ -0,0 +1,57 @@
+module Stretchy
+    class Record
+
+        def self.inherited(base) 
+
+            base.class_eval do
+
+                extend Stretchy::Delegation::GatewayDelegation
+
+                include ActiveModel::Model
+                include ActiveModel::Attributes
+                include ActiveModel::AttributeAssignment
+                include ActiveModel::Naming
+                include ActiveModel::Conversion
+                include ActiveModel::Serialization
+                include ActiveModel::Serializers::JSON
+                include ActiveModel::Validations
+                include ActiveModel::Validations::Callbacks
+                extend ActiveModel::Callbacks
+
+
+
+                include Stretchy::Model::Callbacks
+                include Stretchy::Indexing::Bulk
+                include Stretchy::Persistence
+                include Stretchy::Associations 
+                include Stretchy::Refreshable
+                include Stretchy::Common
+                include Stretchy::Scoping
+                include Stretchy::Utils
+
+                extend Stretchy::Delegation::DelegateCache
+                extend Stretchy::Querying
+
+                # Set up common attributes
+                attribute :id, :string #, default: lambda { SecureRandom.uuid }
+                attribute :created_at, :datetime, default: lambda {  Time.now.utc }
+                attribute :updated_at, :datetime, default: lambda { Time.now.utc }
+
+                # Set the default sort key to be used in sort operations
+                default_sort_key :created_at
+
+                # Defaults max record size returned by #all
+                # overriden by #size
+                default_size 10000
+
+            end
+
+            def initialize(attributes = {})
+                self.assign_attributes(attributes) if attributes
+                super()
+            end
+
+        end
+
+    end
+end

data/lib/stretchy/refreshable.rb

@@ -0,0 +1,15 @@
+module Stretchy
+  module Refreshable
+    extend ActiveSupport::Concern
+
+    included do
+      after_save :refresh_index
+      after_destroy :refresh_index
+    end
+
+    def refresh_index
+      self.class.refresh_index!
+    end
+
+  end
+end

data/lib/stretchy/relation.rb

@@ -0,0 +1,169 @@
+module Stretchy
+    # This class represents a relation to Elasticsearch documents.
+    # It provides methods for querying and manipulating the documents.
+    class Relation
+
+        # These methods can accept multiple values.
+        MULTI_VALUE_METHODS  = [:order, :where, :or_filter, :filter, :bind, :extending, :unscope, :skip_callbacks]
+
+        # These methods can accept a single value.
+        SINGLE_VALUE_METHODS = [:limit, :offset, :routing, :size]
+
+        # These methods cannot be used with the `delete_all` method.
+        INVALID_METHODS_FOR_DELETE_ALL = [:limit, :offset]
+
+        # All value methods.
+        VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
+
+        # Include modules.
+        include Relations::FinderMethods, Relations::SpawnMethods, Relations::QueryMethods, Relations::SearchOptionMethods, Delegation
+
+        # Getters.
+        attr_reader :klass, :loaded
+        alias :model :klass
+        alias :loaded? :loaded
+
+        # Delegates to the results array.
+        delegate :blank?, :empty?, :any?, :many?, to: :results
+
+        # Constructor.
+        #
+        # @param klass [Class] The class of the Elasticsearch documents.
+        # @param values [Hash] The initial values for the relation.
+        def initialize(klass, values={})
+            @klass  = klass
+            @values = values
+            @offsets = {}
+            @loaded = false
+        end
+
+        # Builds a new Elasticsearch document.
+        #
+        # @param args [Array] The arguments to pass to the document constructor.
+        # @return [Object] The new document.
+        def build(*args)
+         @klass.new *args
+        end
+
+        # Returns the results of the relation as an array.
+        #
+        # @return [Array] The results of the relation.
+        def to_a
+
+          load
+          @records
+        end
+        alias :results :to_a
+
+        def response
+          to_a.response
+        end
+
+        # Returns the results of the relation as a JSON object.
+        #
+        # @param options [Hash] The options to pass to the `as_json` method.
+        # @return [Hash] The results of the relation as a JSON object.
+        def as_json(options = nil)
+          to_a.as_json(options)
+        end
+
+        # Returns the Elasticsearch query for the relation.
+        #
+        # @return [Hash] The Elasticsearch query for the relation.
+        def to_elastic
+          query_builder.to_elastic
+        end
+
+        # Creates a new Elasticsearch document.
+        #
+        # @param args [Array] The arguments to pass to the document constructor.
+        # @param block [Proc] The block to pass to the document constructor.
+        # @return [Object] The new document.
+        def create(*args, &block)
+           scoping { @klass.create!(*args, &block) }
+        end
+
+        # Executes a block of code within the scope of the relation.
+        #
+        # @yield The block of code to execute.
+        def scoping
+          previous, klass.current_scope = klass.current_scope, self
+          yield
+        ensure
+          klass.current_scope = previous
+        end
+
+        # Loads the results of the relation.
+        #
+        # @return [Relation] The relation object.
+        def load
+          exec_queries unless loaded?
+
+          self
+        end
+        alias :fetch :load
+
+        # Deletes Elasticsearch documents.
+        #
+        # @param opts [Hash] The options for the delete operation.
+        def delete(opts=nil)
+        end
+
+        # Executes the Elasticsearch query for the relation.
+        #
+        # @return [Array] The results of the query.
+        def exec_queries
+          # Run safety callback
+          klass._circuit_breaker_callbacks.each do |cb|
+            current_scope_values = self.send("#{cb[:options][:in]}_values")
+            next if skip_callbacks_values.include? cb[:name]
+            valid = if cb[:callback].nil?
+              current_scope_values.collect(&:keys).flatten.include? cb[:name]
+            else
+              cb[:callback].call(current_scope_values.collect(&:keys).flatten, current_scope_values)
+            end
+
+            raise Stretchy::Errors::QueryOptionMissing, "#{cb[:name]} #{cb[:options][:message]}" unless valid
+          end
+
+          @records = @klass.fetch_results(query_builder)
+
+          @loaded = true
+          @records
+        end
+
+        # Returns the values of the relation as a hash.
+        #
+        # @return [Hash] The values of the relation.
+        def values
+          Hash[@values]
+        end
+
+        # Returns a string representation of the relation.
+        #
+        # @return [String] The string representation of the relation.
+        def inspect
+          begin
+            entries = to_a.results.take([size_value.to_i + 1, 11].compact.min).map!(&:inspect)
+            message = {}
+            message = {total: to_a.total, max: to_a.total}
+            message.merge!(aggregations: results.response.aggregations.keys) unless results.response.aggregations.nil?
+            message = message.each_pair.collect { |k,v|  "#{k}: #{v}" }
+            message.unshift entries.join(', ') unless entries.size.zero?
+            "#<#{self.class.name} #{message.join(', ')}>"
+          rescue StandardError => e
+            e
+          end
+        end
+
+        private
+
+        # Returns the query builder for the relation.
+        #
+        # @return [QueryBuilder] The query builder for the relation.
+        def query_builder
+          Relations::QueryBuilder.new(values)
+        end
+
+    end
+  end