lycra 0.0.7 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ae19d389fed4af25874ae57afe396eea884e1d5b
-  data.tar.gz: da0c6854220ff3b663919c5aed3d319282d7f7ed
+SHA256:
+  metadata.gz: 5fc3ae92178f1c1b65aef5866d78ba48eaac5ac5a1f26874f9b9de27171af7c5
+  data.tar.gz: 550692ddd9612fa6b13e1899743c40f080efeb3e5f2f99153a1bc2bd4e600bd7
 SHA512:
-  metadata.gz: e3e57b0af1517a9694811487a33a13379ed0e883e6fa761a1c075256d07f2e2983ba03d5b5abca2bd73ac2cadaad7feee1d15b4647e1f2071cd3998dde83e468
-  data.tar.gz: 480a3a64e33b453324a6cab834cc99ba3dd4a7d983b4ccc1ed97b2386a5f506210657d5f96fb2048d4facb0e12a1c4bd3e89d68083c29962587d995815130242
+  metadata.gz: 1425e10b35c3ca78ae95f513535ef8c2568c1f7704045b479be24dcc699277f6ab912023b06c7c882000aa67dc298361dd9216b647cf7f6f3220640b146c0e02
+  data.tar.gz: 156654656586332872962fee77c87272a2cac14342d7a8dbae90e5f9f57088a94189b827536ce4e419d5d3635c32f59bb6ff2ba5954d1e59d174291b76df3826

data/lib/awesome_print/ext/lycra_attribute.rb

@@ -0,0 +1,25 @@
+module AwesomePrint
+  module LycraAttribute
+    def self.included(base)
+      base.send :alias_method, :cast_without_lycra_attribute, :cast
+      base.send :alias_method, :cast, :cast_with_lycra_attribute
+    end
+
+    def cast_with_lycra_attribute(object, type)
+      cast = cast_without_lycra_attribute(object, type)
+      return cast unless defined?(::Lycra::Attributes::Attribute)
+
+      if object.is_a?(::Lycra::Attributes::Attribute)
+        cast = :lycra_attribute
+      end
+
+      cast
+    end
+
+    def awesome_lycra_attribute(object)
+      Formatters::LycraAttributeFormatter.new(object, @inspector).format
+    end
+  end
+end
+
+AwesomePrint::Formatter.send(:include, AwesomePrint::LycraAttribute)

data/lib/awesome_print/ext/lycra_attributes.rb

@@ -0,0 +1,25 @@
+module AwesomePrint
+  module LycraAttributes
+    def self.included(base)
+      base.send :alias_method, :cast_without_lycra_attributes, :cast
+      base.send :alias_method, :cast, :cast_with_lycra_attributes
+    end
+
+    def cast_with_lycra_attributes(object, type)
+      cast = cast_without_lycra_attributes(object, type)
+      return cast unless defined?(::Lycra::Attributes::Collection)
+
+      if object.is_a?(::Lycra::Attributes::Collection)
+        cast = :lycra_attributes
+      end
+
+      cast
+    end
+
+    def awesome_lycra_attributes(object)
+      Formatters::LycraAttributesFormatter.new(object, @inspector).format
+    end
+  end
+end
+
+AwesomePrint::Formatter.send(:include, AwesomePrint::LycraAttributes)

data/lib/awesome_print/formatters/lycra_attribute_formatter.rb

@@ -0,0 +1,58 @@
+module AwesomePrint
+  module Formatters
+    class LycraAttributeFormatter < BaseFormatter
+      attr_reader :attribute, :inspector, :options, :padding
+      # TODO mappings (maybe refactor attribute(s) to accept the document and
+      # behave differently if they're a document attribute or not)
+
+      def initialize(attribute, inspector, padding: 0)
+        @attribute = attribute
+        @inspector = inspector
+        @options = inspector.options
+        @padding = padding
+      end
+
+      def format
+        if options[:multiline]
+          [ 
+            name_and_type,
+            indent + (' ' * (padding + 1)) + description,
+            #indent + (' ' * (padding + 1)) + mappings
+          ].join("\n")
+        else
+          "#{name_and_type} #{description}" #{mappings}"
+        end
+      end
+
+      private
+
+        def name_and_type
+          name = align(attribute.name.to_s, indentation + padding)
+          name = attribute.required? ? name.green : name.cyan
+          type = attribute.type.type
+          type = attribute.nested? ? "[#{type}]" : "#{type}"
+          "#{name} #{type.blue} #{resolver}"
+        end
+
+        def description
+          attribute.description || "No description"
+        end
+
+        def resolver
+          if attribute.resolver.is_a?(Symbol)
+            if attribute.klass.instance_methods.include?(attribute.resolver)
+              (attribute.klass.name.yellowish + "##{attribute.resolver.to_s}".purpleish)
+            else
+              (attribute.klass.subject_type.name.yellowish + "##{attribute.resolver.to_s}".purpleish)
+            end
+          else
+            attribute.resolver.to_s.yellowish
+          end
+        end
+
+        def mappings
+          Inspector.new(options.merge({multiline: false})).awesome(attribute.mappings)
+        end
+    end
+  end
+end

data/lib/awesome_print/formatters/lycra_attributes_formatter.rb

@@ -0,0 +1,26 @@
+module AwesomePrint
+  module Formatters
+    class LycraAttributesFormatter < HashFormatter
+      attr_reader :attributes, :inspector, :options
+
+      def initialize(attributes, inspector)
+        @attributes = attributes
+        @inspector = inspector
+        @options = inspector.options
+      end
+
+      def format
+        padding = attributes.keys.map { |k| k.to_s.length }.max
+        attrs = attributes.values.map do |attr|
+          LycraAttributeFormatter.new(attr, inspector, padding: padding).format
+        end
+
+        if options[:multiline]
+          "#{attributes.to_s} {\n#{attrs.join("\n")}\n#{outdent}}"
+        else
+          "#{attributes.to_s} { #{attrs.join(", ")} }"
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/model/adapters/lycra.rb

@@ -0,0 +1,2 @@
+require 'elasticsearch/model/adapters/lycra/document'
+require 'elasticsearch/model/adapters/lycra/multiple'

data/lib/elasticsearch/model/adapters/lycra/document.rb

@@ -0,0 +1,120 @@
+module Elasticsearch
+  module Model
+    module Adapter
+      module Lycra
+        # An adapter for Lycra::Document-based models
+        module Document
+
+          Adapter.register self,
+                           lambda { |klass| !!defined?(::Lycra::Document::Proxy) && klass.respond_to?(:ancestors) && klass.ancestors.include?(::Lycra::Document::Proxy) }
+
+          module Records
+            attr_writer :options
+
+            def options
+              @options ||= {}
+            end
+
+            # Returns an `ActiveRecord::Relation` instance
+            #
+            def records
+              sql_records = klass.subject_type.where(klass.subject_type.primary_key => ids)
+              sql_records = sql_records.includes(self.options[:includes]) if self.options[:includes]
+
+              # Re-order records based on the order from Elasticsearch hits
+              # by redefining `to_a`, unless the user has called `order()`
+              #
+              sql_records.instance_exec(response.response['hits']['hits']) do |hits|
+                ar_records_method_name = :to_a
+                ar_records_method_name = :records if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 5
+
+                define_singleton_method(ar_records_method_name) do
+                  if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 4
+                    self.load
+                  else
+                    self.__send__(:exec_queries)
+                  end
+                  @records.sort_by { |record| hits.index { |hit| hit['_id'].to_s == record.id.to_s } }
+                end if self
+              end
+
+              sql_records
+            end
+
+            # Prevent clash with `ActiveSupport::Dependencies::Loadable`
+            #
+            def load
+              records.__send__(:load)
+            end
+
+            # Intercept call to the `order` method, so we can ignore the order from Elasticsearch
+            #
+            def order(*args)
+              sql_records = records.__send__ :order, *args
+
+              # Redefine the `to_a` method to the original one
+              #
+              sql_records.instance_exec do
+                define_singleton_method(:to_a) do
+                  if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 4
+                    self.load
+                  else
+                    self.__send__(:exec_queries)
+                  end
+                  @records
+                end
+              end
+
+              sql_records
+            end
+          end
+
+          module Callbacks
+            # Lycra does not use callbacks directly on the documents
+          end
+
+          module Importing
+
+            # Fetch batches of records from the database (used by the import method)
+            #
+            #
+            # @see http://api.rubyonrails.org/classes/ActiveRecord/Batches.html ActiveRecord::Batches.find_in_batches
+            #
+            def __find_in_batches(options={}, &block)
+              query = options.delete(:query)
+              named_scope = options.delete(:scope)
+              preprocess = options.delete(:preprocess)
+
+              scope = subject_type
+              scope = scope.__send__(named_scope) if named_scope
+              scope = scope.instance_exec(&query) if query
+
+              scope.find_in_batches(options) do |batch|
+                yield (preprocess ? self.__send__(preprocess, batch) : batch)
+              end
+            end
+
+            def __transform
+              lambda do |model|
+                json_data = begin
+                  if model.respond_to?(:model_document)
+                    # TODO model_document.as_indexed_json(model)
+                  else
+                    modoc = begin
+                      "#{model.class.name}Document".constantize
+                    rescue NameError => e
+                      raise "Unable to locate a document class for the #{model.class.name} model"
+                    end
+                    modoc.as_indexed_json(model)
+                  end
+                end
+
+                { index: { _id: model.id, data: json_data } }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/model/adapters/lycra/multiple.rb

@@ -0,0 +1,70 @@
+module Elasticsearch
+  module Model
+    module Adapter
+      module Lycra
+
+        module Multiple
+          Adapter.register self, lambda { |klass| klass.is_a? ::Lycra::Multidoc }
+
+          module Records
+            #def documents
+            #  documents_by_type = __documents_by_type
+
+            #  documents = response.response["hits"]["hits"].map do |hit|
+            #    documents_by_type[ __type_for_hit(hit) ][ hit[:_id] ]
+            #  end
+
+            #  documents.compact
+            #end
+
+            def records
+              documents_by_type = __documents_by_type
+
+              records = response.response["hits"]["hits"].map do |hit|
+                documents_by_type[ __type_for_hit(hit) ][ hit[:_id] ]#.subject
+              end
+
+              records.compact
+            end
+
+            def __documents_by_type
+              result = __ids_by_type.map do |klass, ids|
+                documents = __documents_for_klass(klass, ids)
+                ids     = documents.map(&:id).map(&:to_s)
+                mapped = [ klass, Hash[ids.zip(documents)] ]
+                mapped
+              end
+
+              Hash[result]
+            end
+
+            def __documents_for_klass(klass, ids)
+              return klass.subject_type.where(klass.primary_key => ids)
+            end
+
+            def __ids_by_type
+              ids_by_type = {}
+
+              response.response["hits"]["hits"].each do |hit|
+                type = __type_for_hit(hit)
+                ids_by_type[type] ||= []
+                ids_by_type[type] << hit[:_id]
+              end
+              ids_by_type
+            end
+
+            def __type_for_hit(hit)
+              @@__types ||= {}
+
+              @@__types[ "#{hit[:_index]}::#{hit[:_type]}" ] ||= begin
+                ::Lycra::Document::Registry.all.detect do |document|
+                  hit[:_index] =~ /\A#{document.index_name}(-[a-zA-Z0-9]+)?\Z/ && document.document_type == hit[:_type]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lycra.rb

@@ -1,12 +1,23 @@
 require 'logger'
 require 'canfig'
-require 'elasticsearch/persistence'
 require 'elasticsearch/model'
+require 'elasticsearch/model/adapters/lycra'
 require 'lycra/monkeypatches'
 require 'lycra/errors'
-require 'lycra/model'
+require 'lycra/types'
+require 'lycra/attributes'
+require 'lycra/serializer'
+require 'lycra/serializer/model'
+require 'lycra/document'
+require 'lycra/document/model'
+require 'lycra/import'
+require 'lycra/decorator'
+require 'lycra/decorator/model'
+require 'lycra/inheritance'
 require 'lycra/search'
+require 'lycra/multidoc'
 require 'lycra/engine' if defined?(Rails)
+require 'lycra/awesome_print' if defined?(AwesomePrint)
 
 module Lycra
   include Canfig::Module
@@ -32,7 +43,7 @@ module Lycra
   end
 
   def self.client
-    @client ||= Elasticsearch::Client.new(
+    @client ||= ::Elasticsearch::Client.new(
       host: configuration.elasticsearch_url,
       log: configuration.log,
       logger: configuration.logger,
@@ -40,4 +51,10 @@ module Lycra
       tracer: configuration.tracer
     )
   end
+
+  def self.search(query_or_payload, models=[], options={})
+    models = Multidoc.new(models)
+    request = Elasticsearch::Model::Searching::SearchRequest.new(models, query_or_payload, options)
+    Elasticsearch::Model::Response::Response.new(models, request)
+  end
 end

data/lib/lycra/attributes.rb

@@ -0,0 +1,146 @@
+require 'lycra/attributes/collection'
+require 'lycra/attributes/attribute'
+
+module Lycra
+  module Attributes
+    def self.included(base)
+      base.send :attr_reader, :resolved
+      base.send :attr_accessor, :subject
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+
+      base.class_eval do
+        # TODO only for activerecord models??
+        attribute! :id, types.integer
+      end
+    end
+
+    module ClassMethods
+      def inherited(child)
+        super if defined?(super)
+
+        # This clones parent attribues down to inheriting child classes
+        child.send :instance_variable_set,
+                   :@_lycra_attributes,
+                   self.attributes.dup(child)
+      end
+
+      def types
+        Lycra::Types
+      end
+
+      def attribute(name=nil, type=nil, *args, **opts, &block)
+        opts = {cache: cache}.merge(opts)
+        attr = Attribute.new(name, type, *args, **opts.merge({klass: self}), &block)
+        attributes[attr.name] = attr
+      end
+
+      def attribute!(name=nil, type=nil, *args, **opts, &block)
+        attribute(name, type, *args, **opts.merge({required: true}), &block)
+      end
+
+      def attributes
+        @_lycra_attributes ||= Collection.new(self)
+      end
+
+      def subject_type(klass=nil)
+        @_lycra_subject_type = klass if klass
+        @_lycra_subject_type ||= (name.gsub(/(Decorator|Document|Serializer)\Z/, '').constantize rescue nil)
+      end
+
+      def subject_type=(klass)
+        subject_type klass
+      end
+
+      def cache(cache=nil)
+        @_lycra_cache = cache unless cache.nil?
+        @_lycra_cache
+      end
+
+      def resolve!(subj, *args, **context)
+        if subj.is_a?(subject_type)
+          return new(subj).resolve!(*args, **context)
+        elsif subj.is_a?(Enumerable) && subj.first.is_a?(subject_type)
+          return subj.map { |s| resolve!(s, *args, **context) }
+        end
+
+        raise "Invalid subject: #{subj}"
+      end
+
+      def method_missing(meth, *args, &block)
+        if subject_type && subject_type.respond_to?(meth)
+          result = subject_type.send(meth, *args, &block)
+
+          return result.try(:document) || new(result) if result.is_a?(subject_type)
+          return result if result.is_a?(ActiveRecord::Relation)
+          return result.map { |r| r.try(:document) || new(r) } if result.is_a?(Enumerable) && result.first.is_a?(subject_type)
+
+          return result
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(meth, priv=false)
+        (subject_type && subject_type.respond_to?(meth, priv)) || super
+      end
+
+      def inspect
+        "#{name}(subject: #{subject_type}, #{attributes.map { |key,attr| "#{attr.name}: #{attr.nested? ? "[#{attr.type.type}]" : attr.type.type}"}.join(', ')})"
+      end
+    end
+
+    module InstanceMethods
+      delegate :subject_type, to: :class
+
+      def initialize(subject)
+        @subject = subject
+      end
+
+      def attributes
+        @attributes ||= self.class.attributes.dup
+      end
+
+      def resolve!(*args, **options)
+        raise Lycra::MissingSubjectError.new(self) if subject.nil?
+        context = options.slice!(:only, :except)
+
+        @resolved = attributes.map do |key,attr|
+          next if (options.key?(:only) && ![options[:only]].flatten.include?(key)) ||
+                  (options.key?(:except) && [options[:except]].flatten.include?(key))
+          [ key, attr.dup.resolve!(self, args, context) ]
+        end.compact.to_h
+      end
+
+      def resolved?
+        !!@resolved
+      end
+
+      def reload
+        @resolved = nil
+        attributes.values.each(&:reload)
+        subject.send(:reload) if subject.respond_to?(:reload)
+        self
+      end
+
+      def method_missing(meth, *args, &block)
+        return subject if meth == subject_type.to_s.underscore.to_sym
+        return attributes[meth].resolve!(self, *args, &block) if attributes.key?(meth)
+        return subject.send(meth, *args, &block) if subject && subject.respond_to?(meth)
+        super
+      end
+
+      def respond_to_missing?(meth, priv=false)
+        meth == subject_type.to_s.underscore.to_sym || attributes.key?(meth) || (subject && subject.respond_to?(meth, priv)) || super
+      end
+
+      def inspect
+        if resolved?
+          "#<#{self.class.name} subject: #{subject.class}, #{attributes.map { |key,attr| "#{key}: #{resolved[key].try(:to_json) || (attr.nested? ? "[#{attr.type.type}]" : attr.type.type)}"}.join(', ')}>"
+        else
+          "#<#{self.class.name} subject: #{subject.class}, #{attributes.map { |key,attr| "#{attr.name}: #{attr.nested? ? "[#{attr.type.type}]" : attr.type.type}"}.join(', ')}>"
+        end
+      end
+    end
+  end
+end