activerecord-collections 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 04112ca97ff8955d8c031f7f5a2f2a485d542d1e
-  data.tar.gz: 9a7cfa08962b824a6eeba91be93b5aff5a23a37e
+  metadata.gz: f4234629f1bf42416c64069012d7957116937bab
+  data.tar.gz: 2087c0d1a4abe5e4820c112430e52fe7ec3c7438
 SHA512:
-  metadata.gz: af95c3591f0e8829550b4041282b713ef97532ccdfd79ee068467da0b8de6741ffe445792f4109c338fe43108810811db02a3105246bac65754d8e708ceb37fe
-  data.tar.gz: bc5472e5748c8eb9444b5558d756443984dffc3b966b4d03e63e69e499ecb7c9bfb7c7418084dfc53dc1729c5abe8b860e0212f8de7b67729aada847fc938b35
+  metadata.gz: 10b6c0db6816071a0aca2184fc442af40f62b4b796595b951d4c739b48e844c419f9b184fbd6670131a89ae39a6c7f21b1c90ee1514b63ab617ddf5d1d0378f1
+  data.tar.gz: 8fed417c0a2d7f4f889d254c0f7eba27c1c768e83ded7e5bd1e35a6d39838c719ccb90991a9b174a225d0bd9361442fdd99a2cb1cbae1c14b1c45b11bed8c85c

data/lib/active_record/collections/batching.rb

@@ -170,7 +170,7 @@ module ActiveRecord
       end
 
       def first_batch
-        dup.first_batch!
+        dup.first_batch!.is_batch!
       end
 
       def first_batch!
@@ -182,7 +182,7 @@ module ActiveRecord
       end
 
       def next_batch
-        dup.next_batch!
+        dup.next_batch!.is_batch!
       end
 
       def next_batch!
@@ -194,7 +194,7 @@ module ActiveRecord
       end
 
       def prev_batch
-        dup.prev_batch!
+        dup.prev_batch!.is_batch!
       end
 
       def prev_batch!
@@ -202,7 +202,7 @@ module ActiveRecord
       end
 
       def last_batch
-        dup.last_batch!
+        dup.last_batch!.is_batch!
       end
 
       def last_batch!

data/lib/active_record/collections/collectable.rb

@@ -30,22 +30,15 @@ module ActiveRecord
           klass.kollektion
         end
 
+        def values_hash
+          ActiveRecord::Collections::Serializer.to_hash(values.merge({collectable: klass}))
+        end
+        alias_method :to_values_hash, :values_hash
+        alias_method :to_hash, :values_hash
+
         def collection
           # do this with a hash so that we don't cause the relation query to execute
-          kollektion.from_hash({
-            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
-          })
+          kollektion.from_hash(values_hash)
         end
         alias_method :to_collection, :collection
       end

data/lib/active_record/collections/serialization.rb

@@ -18,20 +18,27 @@ module ActiveRecord
           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?
           collection.references!(*hash[:references]) unless hash[:references].empty?
           collection.includes!(*hash[:includes]) unless hash[:includes].empty?
-          collection.where!(*hash[:bind].map { |b| b[:value] }.unshift(hash[:where].join(" AND ").gsub(/\$\d/,'?'))) unless hash[:where].empty?
+
+          wheres = hash[:where].partition { |w| w.is_a?(Hash) }
+          wheres.first.each { |wh| collection.where!(wh) }
+          collection.where!(*hash[:bind].map { |b| b[:value] }.unshift(wheres.last.join(" AND ").gsub(/\$\d/,'?'))) unless wheres.last.empty?
+
           collection.group!(hash[:group]) unless hash[:group].empty?
           collection.order!(hash[:order]) unless hash[:order].empty?
+
           collection.limit!(hash[:limit]) unless hash[:limit].nil?
           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 = hash[:collection] if hash.has_key?(:collection) && !hash[:collection].nil?
           kollektion = kollektion.constantize unless kollektion.is_a?(Class)
           raise "Invalid collection class: #{kollektion}" unless kollektion <= ActiveRecord::Collection
           kollektion
@@ -40,7 +47,7 @@ module ActiveRecord
         def kollektable_from_hash(hash)
           kollektable = nil
           kollektable = hash[:collectable] if hash.has_key?(:collectable)
-          kollektable = kollektable.constantize unless kollektable.is_a?(Class)
+          kollektable = kollektable.constantize unless kollektable.is_a?(Class) || kollektable.nil?
           raise "Invalid collectable model: #{kollektable}" unless kollektable < ActiveRecord::Base
           kollektable
         end
@@ -51,29 +58,22 @@ module ActiveRecord
       end
 
       def to_hash(include_limit=false)
-        h = {
-          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
-        end
-        h
+        values = relation.values.merge({collectable: collectable})
+        values.merge!({limit: nil, offset: nil}) if !include_limit && !try(:is_batch?)
+        values[:collection] = self.class if self.class < ActiveRecord::Collection
+        ActiveRecord::Collections::Serializer.to_hash(values)
       end
       alias_method :to_h, :to_hash
 
+      def as_json(options=nil)
+        h = to_hash
+        h[:collectable] = h[:collectable].try(:name)
+        h[:collection] = h[:collection].name if h.has_key?(:collection)
+        h.as_json(options)
+      end
+
       def to_json(options=nil)
-        to_hash.to_json
+        as_json.to_json(options)
       end
 
       def to_param

data/lib/active_record/collections/serializer.rb

@@ -0,0 +1,141 @@
+module ActiveRecord
+  module Collections
+    class Serializer
+      attr_reader :values
+
+      def self.to_hash(*args)
+        new(*args).to_hash
+      end
+
+      def collectable
+        values[:collectable]
+      end
+
+      def collection
+        values[:collection]
+      end
+
+      def select
+        values[:select]
+      end
+
+      def distinct
+        values[:distinct]
+      end
+
+      def joins
+        values[:joins]
+      end
+
+      def includes
+        values[:includes]
+      end
+
+      def references
+        values[:references]
+      end
+
+      def group
+        values[:group].map { |v| (v.is_a?(String) || v.is_a?(Symbol)) ? v : v.to_sql }
+      end
+
+      def order
+        values[:order].map { |v| (v.is_a?(String) || v.is_a?(Symbol)) ? v : v.to_sql }
+      end
+
+      def limit
+        values[:limit]
+      end
+
+      def offset
+        values[:offset]
+      end
+
+      def bind
+        @bind ||= values[:bind].map { |b| {name: b.first.name.to_s, value: b.last} }
+      end
+
+      def where
+        return @where unless @where.nil?
+
+        @where = values[:where].map { |node| serialize_node(node) }
+        hashed = {}
+        @where.select! do |w|
+          if w.is_a?(Hash)
+            if hashed.has_key?(w.keys.first)
+              hashed[w.keys.first].merge!(w.values.first)
+            else
+              hashed[w.keys.first] = w.values.first
+            end
+            false
+          else
+            true
+          end
+        end.unshift(hashed)
+        @where
+      end
+
+      def to_hash
+        {
+          collectable: collectable,
+          collection: collection,
+          select: select,
+          distinct: distinct,
+          joins: joins,
+          includes: includes,
+          references: references,
+          where: where,
+          bind: bind,
+          group: group,
+          order: order,
+          limit: limit,
+          offset: offset
+        }
+      end
+
+      protected
+
+      def initialize(*args)
+        @values = {
+          collectable: nil,
+          collection: nil,
+          where: [],
+          bind: [],
+          select: [],
+          distinct: nil,
+          group: [],
+          order: [],
+          joins: [],
+          includes: [],
+          references: [],
+          limit: nil,
+          offset: nil
+        }.merge(args.extract_options!)
+      end
+
+      def serialize_node(node)
+        if node.is_a?(String)
+          node
+        elsif node.class < Arel::Nodes::Node
+          case node
+          when Arel::Nodes::Grouping
+            serialize_node(node.expr)
+          when Arel::Nodes::And
+            node.children.map { |child| serialize_node(child) }
+          when Arel::Nodes::Or
+            {or: [serialize_node(node.left), serialize_node(node.right)]}
+          else
+            if node.right.is_a?(Arel::Nodes::BindParam)
+              bound = bind.delete_at(bind.find_index { |b| b[:name] == node.left.name.to_s })[:value]
+            elsif node.right.is_a?(Arel::Nodes::Casted)
+              bound = node.right.val
+            else
+              raise "ActiveRecord::Collection does not know how to serialize this attribute: #{node.left.name} / #{node.right.class.name}"
+            end
+            {node.left.relation.name.to_s => {node.left.name.to_s => bound}}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/collections/version.rb

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

data/lib/activerecord-collections.rb

@@ -3,6 +3,7 @@ require 'active_record/collections/delegation'
 require 'active_record/collections/pagination'
 require 'active_record/collections/records'
 require 'active_record/collections/relation'
+require 'active_record/collections/serializer'
 require 'active_record/collections/serialization'
 require 'active_record/collection'
 require 'active_record/collections/collectable'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-collections
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Mark Rebec
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-02 00:00:00.000000000 Z
+date: 2015-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -111,6 +111,7 @@ files:
 - lib/active_record/collections/records.rb
 - lib/active_record/collections/relation.rb
 - lib/active_record/collections/serialization.rb
+- lib/active_record/collections/serializer.rb
 - lib/active_record/collections/version.rb
 - lib/activerecord-collections.rb
 - spec/active_record/collection_spec.rb