lycra 0.0.7 → 5.0.0

data/lib/lycra/document/registry.rb

@@ -0,0 +1,38 @@
+module Lycra
+  module Document
+    class Registry
+      include Enumerable
+
+      class << self
+        delegate :add, :documents, :to_a, to: :__instance
+
+        def __instance
+          @instance ||= new
+        end
+
+        def all
+          new(documents.reject(&:abstract?))
+        end
+
+        def abstract
+          new(documents.select(&:abstract?))
+        end
+      end
+
+      attr_reader :documents
+      delegate :each, to: :documents
+
+      def initialize(documents=[])
+        @documents = documents
+      end
+
+      def add(klass)
+        @documents << klass
+      end
+
+      def method_missing(meth, *args, **opts, &block)
+        documents.map { |doc| doc.send(meth, *args, **opts, &block) }
+      end
+    end
+  end
+end

data/lib/lycra/engine.rb

@@ -10,7 +10,10 @@ module Lycra
 
     initializer "lycra.elasticsearch.client" do |app|
       Elasticsearch::Model.client = Lycra.client
-      Elasticsearch::Persistence.client = Lycra.client
+    end
+
+    initializer "lycra.load_documents" do
+      Dir[File.join(Rails.root, "app/documents/**/*.rb")].each { |f| require f }
     end
   end
 end

data/lib/lycra/errors.rb

@@ -1,4 +1,15 @@
 module Lycra
+  class AttributeError < StandardError; end
+  class AbstractClassError < StandardError; end
+
+  class MissingSubjectError < StandardError
+    def initialize(document=nil)
+      msg = "This document was initialized with a nil subject. Make sure you set @subject before resolving or call `super` from your initializer."
+
+      super(msg)
+    end
+  end
+
   class DocumentNotFoundError < StandardError
     attr_reader :model
 
@@ -10,7 +21,9 @@ module Lycra
 You must define a corresponding document class for all models utilizing Lycra::Model. For example, if your model is called BlogPost:
 
   # /app/documents/blog_post_document.rb
-  class BlogPostDocument < Lycra::Document
+  class BlogPostDocument
+    include Lycra::Document
+
     index_name 'blog-posts'
   end
 MSG
@@ -18,8 +31,10 @@ MSG
         msg = <<MSG
 You must define a corresponding document class for your #{model.name} model. For example:
 
-  # /app/documents/#{model.name.split('::').map { |n| n.underscore }.join('/')}_document.rb
-  class #{model.name}Document < Lycra::Document
+  # /app/documents/#{model.name.underscore}_document.rb
+  class #{model.name}Document
+    include Lycra::Document
+
     index_name '#{model.name.parameterize.pluralize}'
   end
 MSG

data/lib/lycra/import.rb

@@ -0,0 +1,116 @@
+module Lycra
+  class Import
+    attr_reader :documents
+
+    def self.create(*args, &block)
+      new(*args).create(&block)
+    end
+
+    def self.recreate(*args, &block)
+      new(*args).recreate(&block)
+    end
+
+    def self.destroy(*args, &block)
+      new(*args).destroy(&block)
+    end
+
+    def self.import(*args, **opts, &block)
+      new(*args).import(**opts, &block)
+    end
+
+    def self.rotate(*args, **opts, &block)
+      new(*args).rotate(**opts, &block)
+    end
+
+    def self.reindex(*args, **opts, &block)
+      new(*args).reindex(**opts, &block)
+    end
+
+    def self.truncate(*args, **opts, &block)
+      new(*args).truncate(**opts, &block)
+    end
+
+    def initialize(*documents)
+      @documents = documents
+      @documents = Lycra::Document::Registry.all if @documents.empty?
+    end
+
+    def scopes
+      documents.map do |doc|
+        if doc.import_scope.is_a?(Proc)
+          doc.subject_type.instance_exec(&doc.import_scope)
+        elsif doc.import_scope.is_a?(String) || doc.import_scope.is_a?(Symbol)
+          doc.subject_type.send(doc.import_scope)
+        else
+          doc.subject_type.all
+        end
+      end
+    end
+
+    def total
+      scopes.sum { |scope| scope.count }
+    end
+
+    def create(&block)
+      documents.each do |document|
+        document.create_index! unless document.index_exists?
+        yield(document) if block_given?
+      end
+    end
+
+    def recreate(&block)
+      documents.each do |document|
+        document.delete_alias! if document.alias_exists?
+        document.delete_index! if document.index_exists?
+        document.create_index!
+        yield(document) if block_given?
+      end
+    end
+
+    def destroy(&block)
+      documents.each do |document|
+        document.delete_alias! if document.alias_exists?
+        document.delete_index! if document.index_exists?
+        yield(document) if block_given?
+      end
+    end
+
+    def import(batch_size: 200, scope: nil, query: nil, &block)
+      recreate
+
+      documents.each do |document|
+        document.import! batch_size: batch_size, scope: scope, query: query, &block
+      end
+    end
+
+    def rotate(batch_size: 200, scope: nil, query: nil, &block)
+      create
+
+      documents.each do |document|
+        document.update! batch_size: batch_size, scope: scope, query: query, &block
+
+        unless document.index_aliased?
+          if document.alias_exists?
+            old_index = document.aliased_index
+            document.delete_alias!
+            document.delete_index!(index: old_index)
+          end
+
+          document.create_alias!
+        end
+      end
+    end
+
+    def reindex(batch_size: 200, scope: nil, query: nil, &block)
+      documents.each do |document|
+        document.update! batch_size: batch_size, scope: scope, query: query, &block
+      end
+    end
+
+    def truncate(batch_size: 200, scope: nil, query: nil, &block)
+      documents.each do |document|
+        document.delete! batch_size: batch_size, scope: scope, query: query, &block
+      end
+    end
+  end
+end

data/lib/lycra/inheritance.rb

@@ -0,0 +1,17 @@
+module Lycra
+  module Inheritance
+    attr_accessor :abstract_class
+
+    def self.extended(base)
+      base.send :delegate, :abstract?, to: :class
+    end
+
+    def abstract!
+      @abstract_class = true
+    end
+
+    def abstract?
+      !!abstract_class
+    end
+  end
+end

data/lib/lycra/monkeypatches.rb

@@ -1,44 +1,14 @@
-# The Problem:
-#
-# https://github.com/elastic/elasticsearch-rails/issues/421
-#
-# We create our indices with a timestamp, then alias the basename (without the timestamp) to the timestamped index. When
-# you ask the elasticsearch-model gem for records (instead of results), and it tries to use your models to look them up,
-# it decides which model to use based on the index name and document type. This is a problem for us because our documents
-# use the alias name (i.e. 'my-index') as their index name, but the hits that come back when searching use the timestamped
-# index name (i.e. 'my-index-123456789'), which don't match up using the `==` operator in the original implementation of
-# this method.
+# This is for awesome_print, which wants a to_hash method on objects to print
+# them out in a console.
 
-# The Solution:
-#
-# Instead of checking whether the hit's index name and the model's index name are exactly equal, we use a simple regex pattern
-# to match the index names against each other. The regex pattern used below makes the timestamp optional, and allows for both
-# 'my-index' and 'my-index-123456789' to match against 'my-index'
+require 'elasticsearch/model/response/result'
 
 module Elasticsearch
   module Model
-    module Adapter
-      module Multiple
-        module Records
-          # Returns the class of the model corresponding to a specific `hit` in Elasticsearch results
-          #
-          # @see Elasticsearch::Model::Registry
-          #
-          # @api private
-          #
-          def __type_for_hit(hit)
-            @@__types ||= {}
-
-            @@__types[ "#{hit[:_index]}::#{hit[:_type]}" ] ||= begin
-              Registry.all.detect do |model|
-                # Original Implementation
-                #model.index_name == hit[:_index] && model.document_type == hit[:_type]
-
-                # Our Monkeypatch
-                hit[:_index] =~ /\A#{model.index_name}(-\d+)?\Z/ && model.document_type == hit[:_type]
-              end
-            end
-          end
+    module Response
+      class Result
+        def to_hash
+          to_h
         end
       end
     end

data/lib/lycra/multidoc.rb

@@ -0,0 +1,22 @@
+module Lycra
+  class Multidoc
+    attr_reader :documents
+
+    def initialize(*documents)
+      @documents = documents.flatten
+      @documents = Lycra::Document::Registry.all if @documents.empty?
+    end
+
+    def index_name
+      documents.map { |d| d.alias_name }
+    end
+
+    def document_type
+      documents.map { |d| d.document_type }
+    end
+
+    def client
+      Lycra.client
+    end
+  end
+end

data/lib/lycra/search.rb

@@ -51,9 +51,9 @@ module Lycra
 
     def search(qry=nil, &block)
       if block_given?
-        Elasticsearch::Model.search(instance_eval(&block), models)
+        Lycra.search(instance_eval(&block), models)
       else
-        Elasticsearch::Model.search((qry || to_query), models)
+        Lycra.search((qry || to_query), models)
       end
     end
 

data/lib/lycra/serializer.rb

@@ -0,0 +1,19 @@
+module Lycra
+  module Serializer
+    def self.included(base)
+      base.send :include, Attributes
+      base.send :extend,  Inheritance
+      base.send :alias_method, :serialize!, :resolve!
+
+      base.class_eval do
+        class << self
+          alias_method :serialize!, :resolve!
+        end
+      end
+    end
+
+    def as_json(options={})
+      serialize!(subject).as_json(options)
+    end
+  end
+end

data/lib/lycra/serializer/model.rb

@@ -0,0 +1,35 @@
+module Lycra
+  module Serializer
+    module Model
+      def self.included(base)
+        base.send :extend,  ClassMethods
+        base.send :include, InstanceMethods
+      end
+
+      module ClassMethods
+        def serializer(klass=nil)
+          @_lycra_serializer = klass if klass
+          @_lycra_serializer || ("#{name}Serializer".constantize rescue nil)
+        end
+
+        def serializer=(klass)
+          serializer klass
+        end
+      end
+
+      module InstanceMethods
+        delegate :serialize!, to: :serializer
+
+        def reload
+          @serializer = nil
+          super
+        end
+
+        def serializer(serializer_class=nil)
+          return serializer_class.new(self) if serializer_class
+          @serializer ||= self.class.serializer.new(self)
+        end
+      end
+    end
+  end
+end

data/lib/lycra/types.rb

@@ -0,0 +1,165 @@
+module Lycra
+  module Types
+    class Type
+      attr_reader :value
+
+      class << self
+        def klasses(*klasses)
+          @_klasses = klasses unless klasses.empty?
+          @_klasses || []
+        end
+
+        def type(type=nil)
+          @_type = type if type
+          @_type ||= self.name.demodulize.underscore
+        end
+        alias_method :to_s, :type
+
+        def valid?(value, required=false, nested=false)
+          return false if required && value.nil?
+          return true  if value.nil?
+          return false if nested && !value.is_a?(Enumerable)
+          return true  if nested && value.empty?
+          if nested
+            klasses.any? { |klass| value.all? { |val| val.is_a?(klass) } }
+          else
+            klasses.any? { |klass| value.is_a?(klass) }
+          end
+        end
+
+        def transform(value)
+          value # noop by default
+        end
+      end
+
+      def initialize(value)
+        @value = value
+      end
+
+      def type(type=nil)
+        @type = type if type
+        @type ||= self.class.type
+      end
+
+      def valid?(required=false, nested=false)
+        @valid ||= self.class.valid?(@value, required, nested)
+      end
+
+      def transform
+        @transformed ||= self.class.transform(@value)
+      end
+    end
+
+    class Text < Type
+      klasses ::String
+    end
+
+    def self.text
+      Text
+    end
+
+    class Integer < Type
+      klasses ::Integer
+    end
+
+    def self.integer
+      Integer
+    end
+
+    class Float < Type
+      klasses ::Float
+    end
+
+    def self.float
+      Float
+    end
+
+    class Date < Type
+      klasses ::Date, ::Time, ::DateTime
+    end
+
+    def self.date
+      Date
+    end
+
+    class Boolean < Type
+      def self.valid?(value, required=false, nested=false)
+        [true, false, 0, 1, nil].include?(value)
+      end
+
+      def self.transform(value)
+        return value if [true, false].include?(value)
+        return true  if value == 1
+        false # 0, nil
+      end
+    end
+
+    def self.boolean
+      Boolean
+    end
+
+    class Hash < Type
+      klasses ::Hash
+
+      def self.valid?(value, required=false, nested=false)
+        return true if super(value, required, nested)
+        value.is_a?(Hash) || value.respond_to?(:to_h)
+      end
+    end
+
+    def self.hash
+      Hash
+    end
+
+    class Object < Type
+      klasses ::Hash
+
+      def self.valid?(value, required=false, nested=false)
+        return true if super(value, required, nested)
+        value.respond_to?(:to_h)
+      end
+    end
+
+    def self.object
+      Object
+    end
+
+    class Nested < Type
+      def self.valid?(value, required=false, nested=false)
+        return true if value.nil?
+        value.respond_to?(:each)
+      end
+    end
+
+    def self.nested
+      Nested
+    end
+
+    def self.custom(type)
+      Class.new(Type) do
+        self.type(type)
+
+        def self.valid?(value, required=false, nested=false)
+          return false if required && value.nil?
+          return true  if value.nil?
+          return false if nested && !value.is_a?(Enumerable)
+          return true  if nested && value.empty?
+          if nested
+            value.all? { |val| val.is_a?(type) || val.is_a?(type.subject_type) }
+          else
+            value.is_a?(type) || value.is_a?(type.subject_type)
+          end
+        end
+
+        def self.transform(value)
+          return value.resolve! if value.is_a?(type)
+          if value.is_a?(Enumerable)
+            value.map { |val| type.new(val).resolve! }
+          else
+            type.new(value).resolve!
+          end
+        end
+      end
+    end
+  end
+end