undo-serializer-active_model 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8f6129e916df1177c739956b56adcfb3b1f337b
-  data.tar.gz: 09f23cd4001f82babd417949d40dced4323e359e
+  metadata.gz: a295ea13f84f57828d1f8f160c46776e92cff623
+  data.tar.gz: 65880e189d3907d9a4ff5ca31fe3f9fca9156619
 SHA512:
-  metadata.gz: 4d219d7d0189d6eeb4bd05bc144e663c543aaeb902d1832545e7b0b4003a353a7514a24cf5d9fdc7417f39dfc57675bc68ea320d6cadf073c89373ccc4c7c034
-  data.tar.gz: afda0a79e726b1656deaed0c48d73f6f6052d5414560c91d21a2f9804e20d7d574afa44c3b737bbfa6f7ea7fbba944bd6df5d3c4f8bea346db63bc1b24224e03
+  metadata.gz: d995320ec3063c1f92e11062ce5f75190f78ae98313ad6f8cb5eeef8a54ff7cc64621af57ec3048da98d4ad9353866503cacb024e047b53252a5124d335d26a2
+  data.tar.gz: 6d197310535c87d08e0f27564ee6b2be3fc4854b0fd5e6c3289250edcb5566cdb71cf1e92b7d4a557ebbf8f894adbf124cb3a989cdd8c9379c08c678244b72ac

data/.ruby-version

@@ -1 +1 @@
-2.1.0-p0
+2.1.1

data/Gemfile

@@ -21,7 +21,6 @@ group :test, :development do
   gem "sqlite3", :platform => [:ruby, :mswin, :mingw]
   gem 'factory_girl'
   gem 'faker'
-  gem "active_model_serializers", "~> 0.8"
 end
 
 gemspec

data/README.md

@@ -4,10 +4,9 @@ Undo
 [![Gemnasium Build Status](https://gemnasium.com/AlexParamonov/undo-serializer-active_model.png)](http://gemnasium.com/AlexParamonov/undo-serializer-active_model)
 [![Coverage Status](https://coveralls.io/repos/AlexParamonov/undo-serializer-active_model/badge.png?branch=master)](https://coveralls.io/r/AlexParamonov/undo-serializer-active_model?branch=master)
 [![Gem Version](https://badge.fury.io/rb/undo-serializer-active_model.png)](http://badge.fury.io/rb/undo-serializer-active_model)
+[![Code Climate](https://codeclimate.com/github/AlexParamonov/undo-serializer-active_model.png)](https://codeclimate.com/github/AlexParamonov/undo-serializer-active_model)
 
-ActiveModel serializer for Undo gem.
-
-Designed to be used with `gem "active_model_serializers"`, but does not depends on it.
+ActiveModel serializer for Undo gem. Does not require anything from Rails so is friendly to use with POROs.
 
 Contents
 ---------
@@ -33,16 +32,19 @@ Or install it yourself as:
 
     $ gem install undo-serializer-active_model
 
+Most likely you'll install undo gem as well:
+
+    $ gem install undo
+
 Requirements
 ------------
 1. Ruby >= 1.9
-1. `activesupport` (`active_model_serializers` depends on it)
 
 Usage
 ------------
 
 Gem is designed to be used with Undo gem.  
-Add it in global config:
+Customize Undo to use serializer in global configuration:
 
 ``` ruby
 Undo.configure do |config|
@@ -50,43 +52,36 @@ Undo.configure do |config|
 end
 ```
 
-Custom serializer could be provided to the adapter:
+Custom primary_key set, find_or_initialize and persist `Proc`s could be provided to the adapter:
 ``` ruby
 Undo.configure do |config|
-  config.serializer = 
-    Undo::Serializer::ActiveModel.new serializer: ->(object) { "#{object.class.name}UndoSerializer".constantize.new(object) }
+  config.serializer = Undo::Serializer::ActiveModel.new(
+      primary_key: [:id, :status],
+      find_or_initialize: ->(object_class, pk_attributes) { object_class.find_or_initialize_by pk_attributes },
+      serialize_attributes: ->(object) { object.serializable_hash },
+      persist: ->(object) { object.save! },
+    )
 end
 ```
 
-Or it may be initialized by serializer instance:
-``` ruby
-Undo.configure do |config|
-  config.serializer = 
-    Undo::Serializer::ActiveModel.new CustomSerializer.new
-end
-```
+For ActiveRecord Undo uses reasonable defaults, so most of the time it is not needed to overwrite them.
+It should work with most Virtus objects as well.
 
-As usual any Undo configuration may be set in place on wrap and restore:
+As usual any Undo configuration may be set in place on store, wrap and restore:
 ``` ruby
-Undo.wrap user, serializer: Undo::Serializer::ActiveModel.new
-Undo.restore uuid, serializer: Undo::Serializer::ActiveModel.new
-```
-
-In place using the specific serializer from `gem "active_model_serializers"`:
-``` ruby
-Undo.wrap user, serializer: Undo::Serializer::ActiveModel.new(UserSerializer.new(user))
+Undo.store user, serializer: Undo::Serializer::ActiveRecord.new(primary_key: :uuid)
+Undo.restore uuid, primary_key: :uuid, persist: ->(object) { object.write_to_disk! }
 ```
 
 ### Associations
 
-It is required to set `somethig___association_class_name` as `key` in `active_model_serializer`:
+Add `include` option to serialize the association
 ``` ruby
-class UserSerializer < ActiveModel::Serializer
-  attributes *User.attribute_names.map(&:to_sym)
-  has_many :roles, key: :has_many___roles
-end
+uuid = Undo.store post, include: comments
+Undo.restore uuid
 ```
 
+Will restore post with related comments.
 
 Contacts
 -------------

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.1.0

data/gemfiles/3.0.gemfile

@@ -25,7 +25,6 @@ group :test, :development do
   gem "sqlite3", :platform=>[:ruby, :mswin, :mingw]
   gem "factory_girl"
   gem "faker"
-  gem "active_model_serializers", "~> 0.8"
 end
 
 gemspec :path=>".././"

data/gemfiles/3.1.gemfile

@@ -25,7 +25,6 @@ group :test, :development do
   gem "sqlite3", :platform=>[:ruby, :mswin, :mingw]
   gem "factory_girl"
   gem "faker"
-  gem "active_model_serializers", "~> 0.8"
 end
 
 gemspec :path=>".././"

data/gemfiles/3.2.gemfile

@@ -25,7 +25,6 @@ group :test, :development do
   gem "sqlite3", :platform=>[:ruby, :mswin, :mingw]
   gem "factory_girl"
   gem "faker"
-  gem "active_model_serializers", "~> 0.8"
 end
 
 gemspec :path=>".././"

data/gemfiles/4.0.gemfile

@@ -25,7 +25,6 @@ group :test, :development do
   gem "sqlite3", :platform=>[:ruby, :mswin, :mingw]
   gem "factory_girl"
   gem "faker"
-  gem "active_model_serializers", "~> 0.8"
 end
 
 gemspec :path=>".././"

data/gemfiles/4.1.gemfile

@@ -25,7 +25,6 @@ group :test, :development do
   gem "sqlite3", :platform=>[:ruby, :mswin, :mingw]
   gem "factory_girl"
   gem "faker"
-  gem "active_model_serializers", "~> 0.8"
 end
 
 gemspec :path=>".././"

data/lib/undo/serializer/active_model.rb

@@ -1,65 +1,124 @@
-require "active_support"
-
 module Undo
   module Serializer
     class ActiveModel
-      def initialize(*args)
-        options = args.extract_options!
-        @serializer = args.first
-        @serializer_source = options.fetch :serializer,
-          ->(object) { object.active_model_serializer.new object }
+      def initialize(options = {})
+        load_options options
       end
 
-      def serialize(object)
-        serializer(object).as_json
+      def serialize(object, options = {})
+        return object.map do |record|
+          serialize record, options
+        end if array? object
+
+        load_options options
+
+        attributes = serialize_attributes(object) || {}
+        associations = {}
+        Array(options[:include]).map do |association|
+          associations[association] = serialize(object.public_send association)
+        end
+        pk_attributes = symbolize_keys(attributes).select do |attribute|
+          primary_key_fields.include? attribute
+        end
+
+        {
+          attributes: attributes,
+          associations: associations,
+          meta: {
+            pk_attributes: pk_attributes,
+            class_name: object.class.name,
+          }
+        }
       end
 
-      def deserialize(hash)
-        object_handler, data = hash.first
-        return unless data.is_a? Hash
-        data.stringify_keys!
+      def deserialize(object, options = {})
+        return object.map do |record|
+          deserialize record
+        end if array? object
+
+        load_options options
 
-        ActiveRecord::Base.transaction do
-          initialize_object(object_handler, data).tap do |object|
-            data.each do |field, value|
-              next if "id" == field && object.persisted?
+        hash = symbolize_keys object
+        object_meta = hash.fetch :meta
+        associations = hash.fetch :associations
+        attributes = hash.fetch :attributes
 
-              case field
-              when /___(.*)/ then deserialize_association object, $1,    value
-              else                deserialize_field       object, field, value
-              end
+        with_transaction do
+          initialize_object(object_meta).tap do |object|
+            attributes.each do |field, value|
+              deserialize_field object, field, value
             end
 
-            object.save!
+            # QUESTION: Set associations? object.association_name = deserialize association ?
+            associations.each do |(association_name, association)|
+              deserialize association
+            end
+
+            persist object
           end
         end
-
       end
 
       private
-      attr_reader :serializer_source
+      attr_reader :serialize_attributes_source,
+                  :initialize_object_source,
+                  :persist_object_source
 
-      def serializer(object)
-        @serializer ||= serializer_source.call object
+      def deserialize_field(object, field, value)
+        object.send "#{field}=", value # not public_send!
       end
 
-      def deserialize_association(object, association, values)
-        Array.wrap(values).each do |value|
-          deserialize object.public_send(association) => value
+      def initialize_object(meta)
+        object_class = constantize meta.fetch(:class_name)
+        pk_attributes = meta.fetch :pk_attributes
+
+        find_or_initialize object_class, pk_attributes
+      end
+
+      def with_transaction(&block)
+        if defined? ActiveRecord
+          ActiveRecord::Base.transaction(&block)
+        else
+          block.call
         end
       end
 
-      def deserialize_field(object, field, value)
-        object.send "#{field}=", value # not public_send!
+      def load_options(options)
+        @serialize_attributes_source = options.fetch :serialize_attributes, @serialize_attributes_source ||
+          ->(object) { object.attributes }
+
+        @initialize_object_source = options.fetch :find_or_initialize, @initialize_object_source ||
+          ->(object_class, pk_query) { object_class.respond_to?(:where) && object_class.where(pk_query).first || object_class.new(pk_query) }
+
+        @persist_object_source = options.fetch :persist, @persist_object_source ||
+          ->(object) { object.respond_to?(:save!) && object.save! }
+
+        @primary_key_fields = options.fetch :primary_key, @primary_key_fields || :id
       end
 
-      def initialize_object(object_handler, data)
-        id = data.fetch "id"
-        relation = case object_handler
-                   when String, Symbol then object_handler.to_s.camelize.constantize
-                   else object_handler end
+      def primary_key_fields
+        Array(@primary_key_fields)
+      end
+
+      def serialize_attributes(*args); serialize_attributes_source.call(*args) end
+      def find_or_initialize(*args);   initialize_object_source.call(*args) end
+      def persist(*args);              persist_object_source.call(*args) end
+
+      def array?(object)
+        object.respond_to?(:map) && ! object.is_a?(Hash)
+      end
+      # ActiveSupport methods
+      def symbolize_keys(hash)
+        hash.each_with_object({}) do |(key, value), result|
+          new_key = key.is_a?(String) ? key.to_sym : key
+          new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
+
+          result[new_key] = new_value
+        end
+      end
 
-        relation.where(id: id).first || relation.new(id: id)
+      def constantize(class_name)
+        class_name.split('::').inject(Kernel) { |object, name| object = object.const_get(name); object }
       end
     end
   end

data/spec/undo/serializer/active_model_integration_spec.rb

@@ -2,7 +2,6 @@ require "spec_helper"
 require "support/active_record"
 require "user"
 require "role"
-require "user_serializer"
 
 describe Undo::Serializer::ActiveModel do
   subject { described_class }
@@ -19,17 +18,19 @@ describe Undo::Serializer::ActiveModel do
     expect(restored_user).to be_persisted
   end
 
-  it "restores object and associations" do
-    roles = create_list :role, 3, user: user
-    hash = serializer.serialize user
-    user.delete
-    Role.delete_all # HACK for ActiveRecord 3.0
+  describe "associations" do
+    it "restores provided associations" do
+      roles = create_list :role, 3, user: user
+      hash = serializer.serialize user, include: :roles
+      user.delete
+      Role.delete_all # HACK for ActiveRecord 3.0
 
-    restored_user = serializer.deserialize hash
+      restored_user = serializer.deserialize hash
 
-    restored_user.reload # HACK for ActiveRecord 3.0
-    expect(restored_user).to eq user
-    expect(restored_user.roles).to eq roles
+      restored_user.reload # HACK for ActiveRecord 3.0
+      expect(restored_user).to eq user
+      expect(restored_user.roles).to eq roles
+    end
   end
 
   it "reverts changes to object" do
@@ -43,9 +44,14 @@ describe Undo::Serializer::ActiveModel do
     expect(restored_user).to eq user.reload
   end
 
-  it "detects default serializer for a model" do
-    serializer = subject.new
-    expect(UserSerializer).to receive(:new)
-    serializer.serialize(user)
+  describe "array of objects" do
+    it "restores a collection" do
+      users = create_list :user, 3
+      array = serializer.serialize users, include: :roles
+      users.each &:delete
+
+      restored_users = serializer.deserialize array
+      expect(restored_users).to eq users
+    end
   end
 end

data/spec/undo/serializer/active_model_spec.rb

@@ -3,38 +3,70 @@ require "spec_helper"
 describe Undo::Serializer::ActiveModel do
   subject { described_class }
   let(:serializer) { subject.new }
-  let(:object) { double :object }
-  let(:am_serializer_method) { :as_json }
+  let(:object) { double :object, attributes: { id: 1, foo: "bar", bar: "baz", hello: "world" } }
+
+  describe "custom finder fields" do
+    it "uses finder fields to find the object" do
+      FooBarTestObject = Class.new
+      serializer = subject.new primary_key: [:foo, :bar]
+      allow(object).to receive(:class) { FooBarTestObject }
+
+      expect(FooBarTestObject).to receive(:new).with(foo: "bar", bar: "baz") { object.as_null_object }
+
+      hash = serializer.serialize object
+      serializer.deserialize hash
+    end
+  end
 
   describe "custom serializer" do
-    it "uses provided serializer" do
-      custom_serializer = double :custom_serializer
-      serializer = subject.new custom_serializer
+    it "uses provided attribute serialization" do
+      attribute_serializer = double :attribute_serializer
+      serializer = subject.new serialize_attributes: attribute_serializer
 
-      expect(custom_serializer).to receive am_serializer_method
+      expect(attribute_serializer).to receive(:call).with(object)
       serializer.serialize object
     end
 
-    it "uses custom serializer source" do
-      custom_serializer_source = double :custom_serializer_source
-      custom_serializer = double :custom_serializer
-      serializer = subject.new serializer: custom_serializer_source
+    it "uses provided find_or_initialize deserialization" do
+      deserializer = double :find_or_initialize_deserializer
+      serializer = subject.new find_or_initialize: deserializer
 
-      expect(custom_serializer_source).to receive(:call).with(object) { custom_serializer }
-      expect(custom_serializer).to receive am_serializer_method
-      serializer.serialize object
+      hash = serializer.serialize object
+      expect(deserializer).to receive(:call).with(object.class, id: 1) { object.as_null_object }
+      serializer.deserialize hash
     end
 
-    it "has lower priority than providing the serializer directly" do
-      custom_serializer_source = double :custom_serializer_source
-      custom_serializer = double :custom_serializer
+    it "uses provided way of persisting object" do
+      persister = double :persister
 
-      serializer = subject.new custom_serializer, serializer: custom_serializer_source
+      deserializer = double :find_or_initialize_deserializer
+      allow(deserializer).to receive(:call) { object.as_null_object }
+      serializer = subject.new persist: persister, find_or_initialize: deserializer
 
-      expect(custom_serializer_source).not_to receive(:call)
-      expect(custom_serializer).to receive am_serializer_method
+      hash = serializer.serialize object
+      expect(persister).to receive(:call).with(object)
+      serializer.deserialize hash
+    end
+  end
 
-      serializer.serialize object
+  describe "in place serializer options" do
+    specify "#serialize" do
+      attribute_serializer = double :attribute_serializer
+      serializer = subject.new
+
+      expect(attribute_serializer).to receive(:call).with(object)
+      serializer.serialize object,
+        serialize_attributes: attribute_serializer
+    end
+
+    specify "#deserialize" do
+      deserializer = double :find_or_initialize_deserializer
+      serializer = subject.new
+
+      hash = serializer.serialize object
+      expect(deserializer).to receive(:call).with(object.class, id: 1) { object.as_null_object }
+      serializer.deserialize hash,
+        find_or_initialize: deserializer
     end
   end
 

data/undo-serializer-active_model.gemspec

@@ -7,8 +7,8 @@ Gem::Specification.new do |spec|
   spec.version       = IO.read("VERSION")
   spec.authors       = ["Alexander Paramonov"]
   spec.email         = ["alexander.n.paramonov@gmail.com"]
-  spec.summary       = %q{ActiveModel serializer for Undo gem.}
-  spec.description   = %q{ActiveModel serializer for Undo gem.}
+  spec.summary       = %q{ActiveModel serializer for Undo gem. Does not require anything from Rails so is friendly to use with POROs.}
+  spec.description   = %q{ActiveModel serializer for Undo gem. Does not require anything from Rails so is friendly to use with POROs.}
   spec.homepage      = "http://github.com/AlexParamonov/undo-serializer-active_model"
   spec.license       = "MIT"
 
@@ -17,6 +17,5 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport"
   spec.add_development_dependency 'bundler', '~> 1.0'
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: undo-serializer-active_model
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - Alexander Paramonov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-22 00:00:00.000000000 Z
+date: 2014-03-16 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +24,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-description: ActiveModel serializer for Undo gem.
+description: ActiveModel serializer for Undo gem. Does not require anything from Rails
+  so is friendly to use with POROs.
 email:
 - alexander.n.paramonov@gmail.com
 executables: []
@@ -68,7 +55,6 @@ files:
 - spec/support/active_record/role.rb
 - spec/support/active_record/schema.rb
 - spec/support/active_record/user.rb
-- spec/support/active_record/user_serializer.rb
 - spec/support/ci_helper.rb
 - spec/support/factories.rb
 - spec/undo/serializer/active_model_integration_spec.rb
@@ -94,19 +80,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
-summary: ActiveModel serializer for Undo gem.
+summary: ActiveModel serializer for Undo gem. Does not require anything from Rails
+  so is friendly to use with POROs.
 test_files:
 - spec/spec_helper.rb
 - spec/support/active_record.rb
 - spec/support/active_record/role.rb
 - spec/support/active_record/schema.rb
 - spec/support/active_record/user.rb
-- spec/support/active_record/user_serializer.rb
 - spec/support/ci_helper.rb
 - spec/support/factories.rb
 - spec/undo/serializer/active_model_integration_spec.rb
 - spec/undo/serializer/active_model_spec.rb
-has_rdoc: 

data/spec/support/active_record/user_serializer.rb

@@ -1,6 +0,0 @@
-require "active_model_serializers"
-
-class UserSerializer < ActiveModel::Serializer
-  attributes :id, :name, :email
-  has_many :roles, key: :has_many___roles
-end