activerecord-collections 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e584a84c4e5c74033fe3c722e3ac2ac0637c0c6
-  data.tar.gz: 9ab963d3b8e4a1243dcf98b980f8d03ed4b1360f
+  metadata.gz: 04112ca97ff8955d8c031f7f5a2f2a485d542d1e
+  data.tar.gz: 9a7cfa08962b824a6eeba91be93b5aff5a23a37e
 SHA512:
-  metadata.gz: dc7da22fd53664c88a8f951752e602603f1f33b5458be045d47d5d3688ca32994493b6c22c23d0fa03ae31fdd4c662016d988b3aede109325469b5ee32986fc4
-  data.tar.gz: 7e41289a5a3c5decb18fa639d91f0c52afc238129216ae480bc0b8ea6f3039ad985a9caa4dc969d340eda073c4dbdd1649086f4cc44261c174f5efdc840cbfb3
+  metadata.gz: af95c3591f0e8829550b4041282b713ef97532ccdfd79ee068467da0b8de6741ffe445792f4109c338fe43108810811db02a3105246bac65754d8e708ceb37fe
+  data.tar.gz: bc5472e5748c8eb9444b5558d756443984dffc3b966b4d03e63e69e499ecb7c9bfb7c7418084dfc53dc1729c5abe8b860e0212f8de7b67729aada847fc938b35

data/lib/active_record/collection.rb

@@ -53,7 +53,9 @@ module ActiveRecord
     protected
 
     def initialize(*criteria)
-      if criteria.first.present? && criteria.first.respond_to?(:ancestors) && criteria.first.ancestors.include?(ActiveRecord::Base)
+      criteria.compact!
+
+      if criteria.first.present? && criteria.first.respond_to?(:ancestors) && criteria.first < ActiveRecord::Base
         @collectable = criteria.slice!(0)
       end
 

data/lib/active_record/collections/collectable.rb

@@ -6,6 +6,7 @@ module ActiveRecord
           @collection_class = klass unless klass.nil?
           @collection_class
         end
+        alias_method :collector, :collection_class
 
         def kollektion
           plural_klass = begin
@@ -32,18 +33,18 @@ module ActiveRecord
         def collection
           # do this with a hash so that we don't cause the relation query to execute
           kollektion.from_hash({
-            klass:      klass,
-            select:     select_values,
-            distinct:   distinct_value,
-            joins:      joins_values,
-            references: references_values,
-            includes:   includes_values,
-            where:      where_values.map { |v| v.is_a?(String) ? v : v.to_sql },
-            group:      group_values.map { |v| (v.is_a?(String) || v.is_a?(Symbol)) ? v : v.to_sql },
-            order:      order_values.map { |v| (v.is_a?(String) || v.is_a?(Symbol)) ? v : v.to_sql },
-            bind:       bind_values.map { |b| {name: b.first.name, value: b.last} },
-            limit:      limit_value,
-            offset:     offset_value
+            collectable:  klass,
+            select:       select_values,
+            distinct:     distinct_value,
+            joins:        joins_values,
+            references:   references_values,
+            includes:     includes_values,
+            where:        where_values.map { |v| v.is_a?(String) ? v : v.to_sql },
+            group:        group_values.map { |v| (v.is_a?(String) || v.is_a?(Symbol)) ? v : v.to_sql },
+            order:        order_values.map { |v| (v.is_a?(String) || v.is_a?(Symbol)) ? v : v.to_sql },
+            bind:         bind_values.map { |b| {name: b.first.name, value: b.last} },
+            limit:        limit_value,
+            offset:       offset_value
           })
         end
         alias_method :to_collection, :collection

data/lib/active_record/collections/serialization.rb

@@ -12,7 +12,10 @@ module ActiveRecord
 
         def from_hash(hash)
           hash.symbolize_keys! unless hash.is_a?(HashWithIndifferentAccess)
-          collection = hash.has_key?(:klass) ? new(hash[:klass]) : new
+
+          kollektion = kollektion_from_hash(hash)
+          kollektable = kollektable_from_hash(hash)
+          collection = kollektion.new(kollektable)
           collection.select!(*hash[:select]) unless hash[:select].empty?
           collection.distinct! if hash[:distinct] == true
           collection.joins!(*hash[:joins]) unless hash[:joins].empty?
@@ -25,6 +28,22 @@ module ActiveRecord
           collection.offset!(hash[:offset]) unless hash[:offset].nil?
           collection
         end
+
+        def kollektion_from_hash(hash)
+          kollektion = self
+          kollektion = hash[:collection] if hash.has_key?(:collection)
+          kollektion = kollektion.constantize unless kollektion.is_a?(Class)
+          raise "Invalid collection class: #{kollektion}" unless kollektion <= ActiveRecord::Collection
+          kollektion
+        end
+
+        def kollektable_from_hash(hash)
+          kollektable = nil
+          kollektable = hash[:collectable] if hash.has_key?(:collectable)
+          kollektable = kollektable.constantize unless kollektable.is_a?(Class)
+          raise "Invalid collectable model: #{kollektable}" unless kollektable < ActiveRecord::Base
+          kollektable
+        end
       end
 
       def to_sql
@@ -33,16 +52,18 @@ module ActiveRecord
 
       def to_hash(include_limit=false)
         h = {
-          select:     select_values,
-          distinct:   distinct_value,
-          joins:      joins_values,
-          references: references_values,
-          includes:   includes_values,
-          where:      where_values.map { |v| v.is_a?(String) ? v : v.to_sql },
-          group:      group_values.map { |v| (v.is_a?(String) || v.is_a?(Symbol)) ? v : v.to_sql },
-          order:      order_values.map { |v| (v.is_a?(String) || v.is_a?(Symbol)) ? v : v.to_sql },
-          bind:       bind_values.map { |b| {name: b.first.name, value: b.last} }
+          collectable:  collectable,
+          select:       select_values,
+          distinct:     distinct_value,
+          joins:        joins_values,
+          references:   references_values,
+          includes:     includes_values,
+          where:        where_values.map { |v| v.is_a?(String) ? v : v.to_sql },
+          group:        group_values.map { |v| (v.is_a?(String) || v.is_a?(Symbol)) ? v : v.to_sql },
+          order:        order_values.map { |v| (v.is_a?(String) || v.is_a?(Symbol)) ? v : v.to_sql },
+          bind:         bind_values.map { |b| {name: b.first.name, value: b.last} }
         }
+        h[:collection] = self.class if self.class < ActiveRecord::Collection
         if include_limit || try(:is_batch?)
           h[:limit] = limit_value
           h[:offset] = offset_value

data/lib/active_record/collections/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Collections
-    VERSION = '0.0.12'
+    VERSION = '0.0.13'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-collections
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - Mark Rebec