undo 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4898ed46bb0f2c3a761f82478c73b9d78c6e1a7d
-  data.tar.gz: 6a3b917da4a4ebd61757e227d1e54e090dd23c05
+  metadata.gz: 6bbec1f206620c902a60106546a48d9b126a31d8
+  data.tar.gz: 1e0f6f864cc9bc39bbf80950e6b9071d4b436814
 SHA512:
-  metadata.gz: 5675e00c800a9e4e6a590e112fe331b211e6f57f97d1b851a335343c721e89c06c4d0325617a8696da4a8fb8e25f1cf7b38bee0c2d3e85d9de42428abfa23e86
-  data.tar.gz: 955338eac937b4825f4604c1601d43b0032d6bdf70b685ea1469d3ed3aef8329be1bf085284c3fd765ba03eb5338d8b967e08c33afa63d5b42755cd87f082095
+  metadata.gz: 8e08e8aa4f48fe64d67651e07a6f305ef50f7192fbf8f75b06d26bbaf321fbc53d77b7130523719c7885efe9514627eee6691e82b1cbc7385ba4b2210ffa8f49
+  data.tar.gz: 3dbb5154581a0e24a443e9002d037b43648a542a73f92096018073af42114f16caa80083edb26519106877c51cf35f8c019e27eef55fff182295e2d515a2c0e3

data/.ruby-version

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

data/README.md

@@ -1,19 +1,25 @@
 Undo
 ==========
 [![Build Status](https://travis-ci.org/AlexParamonov/undo.png?branch=master)](https://travis-ci.org/AlexParamonov/undo)
-[![Gemnasium Build Status](https://gemnasium.com/AlexParamonov/undo.png)](http://gemnasium.com/AlexParamonov/undo)
 [![Coverage Status](https://coveralls.io/repos/AlexParamonov/undo/badge.png?branch=master)](https://coveralls.io/r/AlexParamonov/undo?branch=master)
+[![Code Climate](https://codeclimate.com/github/AlexParamonov/undo.png)](https://codeclimate.com/github/AlexParamonov/undo)
+[![Gemnasium Build Status](https://gemnasium.com/AlexParamonov/undo.png)](http://gemnasium.com/AlexParamonov/undo)
 [![Gem Version](https://badge.fury.io/rb/undo.png)](http://badge.fury.io/rb/undo)
 
-Undo reverts operation made upon object.  
-It stores the object state before the mutator operation and allows to
+The Undo restores previous object state.  
+It stores the object state before the mutation and allows to
 restore this state later.
 
-Undo uses adapters for storage (Redis, ActiveRecord, etc) and custom
-serializers (ActiveRecord, Virtus, etc). It is very lightweight
-solution that can be used as well with heavy ActiveRecord as with
-simple Hash or Virtus objects. No database required: store data as it
-suites you.
+Lightweight, modular and very flexible library that works as with
+Rails, as with plain Ruby. No specific persistence required: store
+data as it suites you.
+
+The Undo uses plugable adapters for storage such as Redis,
+RailsCache. And serializers such as ActiveModel for example. Simple
+interface makes it easy to implement new adapters or tweak existing.
+
+Most of adapters and serializers have no external dependencies and can
+be used with similary quaking objects.
 
 Contents
 ---------
@@ -23,11 +29,14 @@ Contents
     1. Undo operation
     1. Configuration options
     1. In place configuration
+    1. Pass through options
+    1. Utils
 1. Contacts
 1. Compatibility
 1. Contributing
 1. Copyright
 
+
 Installation
 ------------
 
@@ -43,146 +52,159 @@ Or install it yourself as:
 
     $ gem install undo
 
+
 Requirements
 ------------
 1. Ruby 1.9 or above
-1. gem virtus ~> 1.0
+1. gem [virtus](https://github.com/solnic/virtus) ~> 1.0
+
 
 Usage
 -----
 
 ### Undo operation
 
-``` ruby
-uuid = Undo.store object
-Undo.restore uuid
-```
+    uuid = Undo.store object
+
+    # ... 
+    # do something destructive
+    # ...
+
+    Undo.restore uuid
+
 That is basically it :)
 
-Additionally possible to wrap object in Undo decorator:
-
-``` ruby
-decorated_object = Undo.wrap object
-Undo.restore decorated_object.uuid
-```
-Use decorated_object as usual afterwards. Undo gem will store object
-state on each hit to `mutator methods`. By default mutator_methods are
-`update`, `delete`, `destroy`. Those methods can be changed either in
-place or using global configuration (see below).
-
-To use something more advanced rather plain memory storage and
-pass through serializer, configure the Undo:  
-
-``` ruby
-Undo.configure do |config|
-  config.storage = Undo::Storage::RailsCache.new
-  config.serializer = Undo::Serializer::ActiveModel.new
-end
-```
-gem `undo-storage-rails_cache` and gem `undo-serializer-active_model` are required for this.  
-There are a bunch of other Rails free adapters. Read about them in configuration chapter below.
+To use something more advanced than plain memory storage and
+pass through serializer, configure the Undo:
 
-### UUID
+    Undo.configure do |config|
+      config.storage = Undo::Storage::RailsCache.new
+      config.serializer = Undo::Serializer::ActiveModel.new
+    end
+
+It allows to serialize and deserialize ActiveRecord models (and
+POROs after implementing the #attributes method) and store it to Rails
+cache. See those gems documentation for more details:
+
+* [gem `undo-storage-rails_cache`](https://github.com/AlexParamonov/undo-storage-rails_cache)
+* [gem `undo-serializer-active_model`](https://github.com/AlexParamonov/undo-serializer-active_model) 
+
+There are more adapters. Read about them in configuration chapter below.
+
+When storage does not garbage collect old records, call 
 
-By default uuids are generated by `SecureRandom.uuid`. The generator is managed by `uuid_generator` 
-setting (see below in configuration chapter).
+    Undo.delete uuid
 
-UUID can be provided to both #wrap and #store methods and it will be used instead of generated one:  
+to manually delete related data in storage. It accepts the same options as store/restore.
 
-``` ruby
-uuid = "uniq identifier"
+### UUID
+
+UUID is a uniq key used by the Undo to store and retrieve data. It is
+generated automatically, but it is possible to either provide custom
+uuid or custom uuid generator.
 
-Undo.store object, uuid: uuid
-Undo.restore uuid
-```
+    # use generated uuid
+    uuid = Undo.store object
+    Undo.restore uuid
 
-If object respond to #uuid method then it value will be used instead:
+    # manually specify uuid
+    uuid = "uniq identifier"
+    Undo.store object, uuid: uuid
+    Undo.restore uuid
 
-``` ruby
-object = OpenStruct.new uuid: "uniq identifier"
-Undo.store object # => uniq identifier
-Undo.restore "uniq identifier"
-```
+    # specify uuid generator in place
+    uuid = Undo.store object, uuid_generator: ->(object) { "#{object.class.name}_#{object.id}" }
+    Undo.restore uuid
+
+By default uuids are generated by `SecureRandom.uuid`. The generator
+set by `uuid_generator` option which may be set in place as shown
+above or in global configuration (see below).
 
 ### Configuration options
 
-`storage` option responsible for putting and fetching object state to or from some storage.  
-Implement `put(uuid, object)` and `fetch(uuid)` methods.  
-Currently available storages:
-* `Undo::Storage::Memory` simple runtime storage (Hash)
-* `gem "undo-storage-rails_cache"` designed for Rails, but can be used with any ducktype cache store
-* `gem "undo-storage-redis"` designed to be used with `gem "redis"` from v0.1 to current
+#### Storage
+
+The `storage` option is responsible of defining a storage adapter that
+can store, fetch and delete object state from storage.
+
+Adapter must implement `store(uuid, object, options)`, `fetch(uuid, options)` and
+optionally `delete(uuid, options)` methods. Naming follows ruby `Hash`
+interface.
+
+Currently available storage adapters:
+
+* [`Undo::Storage::Memory`](https://github.com/AlexParamonov/undo/blob/master/lib/undo/storage/memory.rb) is a simple runtime storage (ruby Hash object).
+* [`gem "undo-storage-rails_cache"`](https://github.com/AlexParamonov/undo-storage-rails_cache) designed for Rails cache, but can be used with any similarly quaking cache store. Rails constant may not even be defined.
+* [`gem "undo-storage-redis"`](https://github.com/AlexParamonov/undo-storage-redis) designed to be used with `gem "redis"`
+
+Check the [documentation on Github](http://github.com/AlexParamonov/undo/README.md)
+for current list of available storage adapters.
 
-See also [documentation](http://github.com/AlexParamonov/undo)
-on project repository for full list of currently available storage adapters.
+#### Serializer
 
-To convert objects to data that can be processed by storage adapters and backward, use `serializers`:
+To convert objects to hashes that can be processed by storage adapters
+and backward, `serializer` is used:
 
-``` ruby
-Undo.configure do |config|
-  config.serializer = CustomSerializer.new
-end
-```
+    Undo.configure do |config|
+      config.serializer = CustomSerializer.new
+    end
+
+Serializer must implement `serialize(object, options)` and
+`deserialize(object, options)` methods.
 
 Currently available serializers:
-* `Undo::Serializer::Null` pass though serializer. It do nothing and returns whatever passed to it.
-* `gem undo-serializer-active_model` depends on #attributes method so can be used with Virtus and PORO objects as well as with ActiveRecord objects.
 
-Check [documentation](http://github.com/AlexParamonov/undo) on project
-repository for currently available serializers.
+* [`Undo::Serializer::Null`](https://github.com/AlexParamonov/undo/blob/master/lib/undo/serializer/null.rb) passes through object without any convertions. It do nothing and returns whatever passed to it.
+* [`gem undo-serializer-active_model`](https://github.com/AlexParamonov/undo-serializer-active_model) allows to serialize the ActiveRecord models as well as POROs (with implemented #attributes method).
+* [`gem undo-serializer-primitive`](https://github.com/AlexParamonov/undo-serializer-primitive) serializes primitive values. Is used by active_model serializer
 
-`uuid_generator` option allows to setup custom uuid generator.
+Check the [documentation on Github](http://github.com/AlexParamonov/undo/README.md)
+for current list of available serializers.
 
-By default it is using `SecureRandom.uuid`.  
-To define custom uuid generator use `uuid_generator` option:
+Serializer could return any type of object, Hash is not forced. But in
+this case compatible storage adapter should be used.
 
-``` ruby
-Undo.configure do |config|
-  config.uuid_generator = ->(object) { "#{object.class.name}_#{object.id}" }
-end
-```
+#### UUID generator
 
-`mutator methods` option defines a list of methods that will trigger storage#put
-By default mutator_methods are `update`, `delete`, `destroy`.  
-To append custom mutator_methods use  
+`uuid_generator` option allows to setup custom uuid generator:
 
-``` ruby
-Undo.configure do |config|
-  config.mutator_methods += [:put, :push, :pop]
-end
-```
+    Undo.configure do |config|
+      config.uuid_generator = ->(object) { "#{object.class.name}_#{object.id}" }
+    end
 
-### In place configuration
+By default it is using `SecureRandom.uuid`.
 
-Any configuration option from previous chapter can be applied in
-place for given operation. To restore object from another storage use
-`storage` option:
+### In place configuration
 
-``` ruby
-Undo.restore uuid, storage: AnotherStorage.new
-```
+Any configuration option from previous chapter can be applied in place
+for a given operation. 
 
-To wrap an object using custom mutator_methods use `mutator_methods` option:
+For example to restore object from another storage, the `storage`
+option may be used in place:
 
-``` ruby
-Undo.wrap object, mutator_methods: [:save]
-```
+    Undo.restore uuid, storage: AnotherStorage.new
 
 To use custom serializer or deserializer use `serializer` option:
 
-``` ruby
-Undo.wrap post, serializer: PostSerializer.new(post)
-post.destroy
-Undo.restore uuid, serializer: PostDeserializer.new(options)
-```
+    Undo.store post, serializer: PostSerializer.new(post)
+    Undo.restore uuid, serializer: PostDeserializer.new(options)
+
+and so on.
+
+### Pass through options
+
+Any option, that is not recognized by the Undo as configuration
+option, will be bypass to the serializer and storage adapter:
+
+    Undo.store post, include: :comments, expires_in: 1.hour
 
-Additionally when given serializer accepts additional options to
-`#serialize` or `#deserialize`, those options can be set in place as well:
+Same applies for `#restore` and `#delete` methods.
 
-``` ruby
-Undo.store post, include: :comments
-```
+### Utils
 
+* [`Undo::Container::Json`](https://github.com/AlexParamonov/undo/blob/master/lib/undo/container/json.rb) used to pack and unpack hashes in storages
+* [`Undo::Storage::Adapter`](https://github.com/AlexParamonov/undo/blob/master/lib/undo/storage/adapter.rb) abstract storage adapter that provides pack and unpack methods
+* [Shared integration test](https://github.com/AlexParamonov/undo/blob/master/lib/undo/integration/shared_undo_integration_examples.rb) can be used in storage or serializers to verify integrity with Undo gem versions
 
 Contacts
 -------------
@@ -207,11 +229,11 @@ See [build history](http://travis-ci.org/#!/AlexParamonov/undo/builds)
 
 ## Contributing
 
-1. Fork repository ( http://github.com/AlexParamonov/undo/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
+1. [Fork repository](http://github.com/AlexParamonov/undo/fork)
+2. Create feature branch (`git checkout -b my-new-feature`)
+3. Commit changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+5. Create new Pull Request on Github
 
 Copyright
 ---------

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/undo.rb

@@ -1,44 +1,32 @@
 require "undo/version"
 require "undo/config"
-require "undo/wrapper"
+require "undo/keeper"
 
 module Undo
-  def self.configure(&block)
-    block_given? ? block.call(config) : config
+  def self.configure
+    yield config
   end
 
   def self.store(object, options = {})
-    config.with(options) do |config|
-      uuid(object, options).tap do |uuid|
-        config.storage.put uuid,
-                           config.serializer.serialize(object, config.filter(options))
-      end
-    end
+    keeper(options).store object
   end
 
   def self.restore(uuid, options = {})
-    config.with(options) do |config|
-      config.serializer.deserialize config.storage.fetch(uuid),
-                                    config.filter(options)
-
-    end
+    keeper(options).restore uuid
   end
 
-  def self.wrap(object, options = {})
-    options[:uuid] ||= uuid object, options
-    config.with(options) do |config|
-      Wrapper.new object, options.merge(mutator_methods: config.mutator_methods)
-    end
+  def self.delete(uuid, options = {})
+    keeper(options).delete uuid
   end
 
   private
-  def self.uuid(object, options = {})
-    options[:uuid] || config.uuid_generator.call(object)
+  def self.config
+    @config ||= Config.new
   end
 
-  def self.config
-    @config ||= Undo::Config.new
+  def self.keeper(options)
+    Keeper.new(config, options)
   end
 
-  private_class_method :uuid, :config
+  private_class_method :config, :keeper
 end

data/lib/undo/config.rb

@@ -1,35 +1,28 @@
 require "virtus"
+require "undo/serializer/null"
+require "undo/storage/memory"
+require "securerandom"
 
 module Undo
   class Config
     include Virtus.model
 
-    attribute :mutator_methods, Array[Symbol], default: [:update, :delete, :destroy]
+    attribute :serializer,      Object,  default: Undo::Serializer::Null.new
+    attribute :storage,         Object,  default: Undo::Storage::Memory.new
+    attribute :uuid_generator,  Proc,    default: :default_uuid_generator
 
-    attribute :uuid_generator, Proc, default: ->(config, _) {
-      require "securerandom"
-      ->(object) { SecureRandom.uuid }
-    }
-    attribute :serializer, Object, default: ->(config, _) {
-      require "undo/serializer/null"
-      Undo::Serializer::Null.new
-    }
-    attribute :storage, Object, default: ->(config, _) {
-      require "undo/storage/memory"
-      Undo::Storage::Memory.new serializer: config.serializer
-    }, lazy: true
-
-    def with(attribute_updates = {}, &block)
-      config = attribute_updates.empty? ? self
-                                        : self.class.new(attribute_set.get(self).merge attribute_updates)
-
-      block_given? ? block.call(config) : config
+    def with(attribute_updates = {})
+      self.class.new attributes.merge attribute_updates
     end
 
     def filter(options)
-      options.delete_if do |key, _|
-        attributes.keys.include? key
-      end
+      attribute_names = attribute_set.map(&:name)
+      options.reject { |key, _| attribute_names.include? key.to_sym }
+    end
+
+    private
+    def default_uuid_generator
+      -> object { SecureRandom.uuid }
     end
   end
 end

data/lib/undo/container/json.rb

@@ -0,0 +1,15 @@
+require 'json'
+
+module Undo
+  module Container
+    class Json
+      def pack(object)
+        object.to_json
+      end
+
+      def unpack(json)
+        JSON.load json
+      end
+    end
+  end
+end

data/lib/undo/integration/shared_undo_integration_examples.rb

@@ -0,0 +1,31 @@
+shared_examples "undo integration" do
+  subject { Undo }
+  let(:object) { Hash.new hello: :world }
+
+  it "stores and restores object" do
+    uuid = subject.store object
+    expect(subject.restore uuid).to eq object
+  end
+
+  it "deletes stored object" do
+    uuid = subject.store object
+    subject.delete uuid
+    expect { subject.restore uuid }.to raise_error(KeyError)
+  end
+
+  it "delete an unexisted key does not raise an error" do
+    expect { subject.delete "does not exist" }.not_to raise_error
+  end
+
+  describe "special cases" do
+    it "stores and restores nil" do
+      uuid = subject.store nil
+      expect(subject.restore uuid).to eq nil
+    end
+
+    it "stores and restores array" do
+      uuid = subject.store [1,2,3]
+      expect(subject.restore uuid).to eq [1,2,3]
+    end
+  end
+end

data/lib/undo/keeper.rb

@@ -0,0 +1,36 @@
+require "forwardable"
+
+module Undo
+  class Keeper
+    extend Forwardable
+
+    def initialize(config, options)
+      @config = config.with options
+      @options = config.filter options
+    end
+
+    def store(object)
+      build_uuid(object).tap do |uuid|
+        reflection = serializer.serialize object, options
+        storage.store uuid, reflection, options
+      end
+    end
+
+    def restore(uuid)
+      reflection = storage.fetch uuid, options
+      serializer.deserialize reflection, options
+    end
+
+    def delete(uuid)
+      storage.delete uuid, options
+    end
+
+    private
+    attr_reader :config, :options
+    def_delegators :config, :storage, :serializer, :uuid_generator
+
+    def build_uuid(object)
+      options[:uuid] || uuid_generator.call(object)
+    end
+  end
+end

data/lib/undo/storage/adapter.rb

@@ -0,0 +1,31 @@
+require "undo/container/json"
+
+module Undo
+  module Storage
+    class Adapter
+      def initialize(options = {})
+        @options = options
+        @container = options.fetch(:container) { Undo::Container::Json.new }
+      end
+
+      def store(uuid, object, options = {}) end
+      def fetch(uuid, options = {}) end
+      def delete(uuid, options = {}) end
+
+      private
+      attr_reader :options, :container
+
+      def pack(object)
+        container.pack object
+      end
+
+      def unpack(data)
+        container.unpack data
+      end
+
+      def adapter_options(local_options)
+        options.merge local_options
+      end
+    end
+  end
+end

data/lib/undo/storage/memory.rb

@@ -4,17 +4,19 @@ module Undo
       def initialize(options = {})
       end
 
-      def put(uuid, object)
+      def store(uuid, object, options = {})
         storage[uuid] = object
       end
 
-      def fetch(uuid)
+      def fetch(uuid, options = {})
         storage.fetch(uuid)
       end
 
-      private
-      attr_writer :storage
+      def delete(uuid, options = {})
+        storage.delete(uuid)
+      end
 
+      private
       def storage
         @storage ||= {}
       end

data/lib/undo/version.rb

@@ -1,3 +1,3 @@
 module Undo
-  VERSION = "0.1.1"
+  VERSION = IO.read("VERSION")
 end

data/spec/spec_helper_lite.rb

@@ -1,12 +1,5 @@
-if !!ENV['CI']
-  require 'coveralls'
-  Coveralls.wear!
-else
-  require 'pry'
-end
-
-ENV['RAILS_ENV'] ||= 'test'
 require 'rspec'
+require_relative "support/ci_helper"
 require 'undo'
 
 $: << File.expand_path('../lib', File.dirname(__FILE__))

data/spec/support/ci_helper.rb

@@ -0,0 +1,16 @@
+if !!ENV["CI"]
+  require 'simplecov'
+  require 'coveralls'
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/vendor/'
+    minimum_coverage(90)
+  end
+else
+  require "pry"
+end

data/spec/undo/config_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper_lite"
+
+describe Undo::Config do
+  describe "#filter" do
+    it "removes known attributes" do
+      subject.class.attribute :known
+      expect(subject.filter known: true, unknown: true).to eq unknown: true
+    end
+  end
+end

data/spec/undo/container/json_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper_lite"
+require "undo/container/json"
+
+describe Undo::Container::Json do
+  let(:container) { described_class.new }
+
+  it "packs to json" do
+    json = container.pack "hello" => "world"
+    expect(json).to eq '{"hello":"world"}'
+  end
+
+  it "unpaks from json" do
+    hash = container.unpack '{"hello":"world"}'
+    expect(hash).to eq "hello" => "world"
+  end
+end

data/spec/undo/serializer/null_spec.rb

@@ -2,18 +2,23 @@ require "spec_helper_lite"
 require "undo/serializer/null"
 
 describe Undo::Serializer::Null do
-  subject { described_class }
-  let(:serializer) { described_class.new }
+  let(:object) { double :object }
 
   describe "returns passed argument" do
-    let(:object) { double :object }
-
     specify "#serialize" do
-      expect(serializer.serialize object).to eq object
+      expect(subject.serialize object).to eq object
     end
 
     specify "#deserialize" do
-      expect(serializer.deserialize object).to eq object
+      expect(subject.deserialize object).to eq object
     end
   end
+
+  it "accepts options" do
+    options = { foo: :bar }
+    expect do
+      subject.serialize object, options
+      subject.deserialize object, options
+    end.not_to raise_error
+  end
 end

data/spec/undo/storage/memory_spec.rb

@@ -2,12 +2,25 @@ require "spec_helper_lite"
 require 'undo/storage/memory'
 
 describe Undo::Storage::Memory do
-  subject { described_class }
-  let(:adapter) { subject.new }
   let(:object) { double :object }
 
   it "stores any object" do
-    adapter.put 123, object
-    expect(adapter.fetch 123).to eq object
+    subject.store 123, object
+    expect(subject.fetch 123).to eq object
+  end
+
+  it "deletes stored object" do
+    subject.store 123, object
+    subject.delete 123
+    expect { subject.fetch 123 }.to raise_error(KeyError)
+  end
+
+  it "accepts options" do
+    options = { foo: :bar }
+    expect do
+      subject.store 123, object, options
+      subject.fetch 123, options
+      subject.delete 123, options
+    end.not_to raise_error
   end
 end

data/spec/undo_spec.rb

@@ -1,13 +1,11 @@
 require "spec_helper_lite"
+require "undo/integration/shared_undo_integration_examples"
 
 describe Undo do
   let(:object) { double :object, change: true }
   subject { described_class }
 
-  it "stores and restores object" do
-    uuid = subject.store object
-    expect(subject.restore uuid).to eq object
-  end
+  include_examples "undo integration"
 
   it "stores and restores object using provided uuid" do
     uuid = "uniq_identifier"
@@ -16,13 +14,13 @@ describe Undo do
     expect(subject.restore uuid).to eq object
   end
 
-  describe "serializing" do
-    let(:storage) { double :storage }
+  describe "serialization" do
     let(:serializer) { double :serializer }
+    let(:storage) { double :storage }
 
     it "serializes data before storing" do
       expect(serializer).to receive(:serialize).with(object, anything).ordered
-      expect(storage).to receive(:put).ordered
+      expect(storage).to receive(:store).ordered
 
       subject.store object,
         storage: storage,
@@ -30,17 +28,19 @@ describe Undo do
     end
 
     it "deserializes data before restoring" do
-      uuid = subject.store object
-
-      expect(storage).to receive(:fetch).and_return(foo: :bar).ordered
-      expect(serializer).to receive(:deserialize).with({ foo: :bar }, anything).ordered
+      expect(storage).to receive(:fetch).and_return(object).ordered
+      expect(serializer).to receive(:deserialize).with(object, anything).ordered
 
-      subject.restore uuid,
+      subject.restore "uuid",
         storage: storage,
         serializer: serializer
     end
+  end
+
+  describe "pass through options to serializer" do
+    let(:serializer) { double :serializer }
 
-    it "pass through options from store to serialize" do
+    specify "from #store" do
       expect(serializer).to receive(:serialize).with(object, foo: :bar)
 
       subject.store object,
@@ -48,19 +48,7 @@ describe Undo do
         foo: :bar
     end
 
-    it "pass through options from wrap to serialize" do
-      expect(serializer).to receive(:serialize)
-
-      wrapper = subject.wrap object,
-        serializer: serializer,
-        mutator_methods: :change,
-        foo: :bar
-
-      wrapper.change
-    end
-
-
-    it "pass through options from restore to deserialize" do
+    specify "from #restore" do
       uuid = subject.store object
       expect(serializer).to receive(:deserialize).with(object, foo: :bar)
 
@@ -70,39 +58,23 @@ describe Undo do
     end
   end
 
-  describe "#wrap" do
-    before do
-      subject.configure do |config|
-        config.mutator_methods = [:change]
-      end
-    end
-
-    it "is a decorator" do
-      object = %w[hello world]
+  describe "pass through options to storage" do
+    let(:storage) { double :storage }
 
-      decorator = subject.wrap object
-      expect(object).to receive(:some_method)
-      decorator.some_method
+    specify "from #store" do
+      expect(storage).to receive(:store).with(anything, object, foo: :bar)
 
-      expect(decorator.class).to eq Array
-      expect(decorator).to be_a Array
+      subject.store object,
+        storage: storage,
+        foo: :bar
     end
 
-    describe "restores" do
-      specify "using provided uuid" do
-        uuid = "uniq_identifier"
-        model = subject.wrap object, uuid: uuid
-        model.change
-
-        expect(subject.restore uuid).to eq object
-      end
+    specify "from #restore" do
+      expect(storage).to receive(:fetch).with("uuid", foo: :bar)
 
-      specify "using gerenated uuid" do
-        model = subject.wrap object
-        model.change
-
-        expect(subject.restore model.uuid).to eq object
-      end
+      subject.restore "uuid",
+        storage: storage,
+        foo: :bar
     end
   end
 end

data/undo.gemspec

@@ -1,21 +1,17 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'undo/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "undo"
-  spec.version       = Undo::VERSION
+  spec.version       = IO.read("VERSION")
   spec.authors       = ["Alexander Paramonov"]
   spec.email         = ["alexander.n.paramonov@gmail.com"]
   spec.summary       = %q{Reverts operation made upon object}
   spec.description   = %q{
-Undo reverts operation made upon object.
-It stores the object state before the mutator operation and allows to restore this state later.
-
-Undo uses adapters for storage (Redis, ActiveRecord, etc) and custom serializers (ActiveRecord, Virtus, etc).
-It is very lightweight solution that can be used as well with heavy ActiveRecord as with simple Hash or Virtus objects.
-No database required: store data as it suites you.
+The Undo restores previous object state.
+Lightweight, modular and very flexible library that works as with
+Rails, as with plain Ruby.
 }
   spec.homepage      = "http://github.com/AlexParamonov/undo"
   spec.license       = "MIT"
@@ -26,8 +22,8 @@ No database required: store data as it suites you.
   spec.require_paths = ["lib"]
 
   spec.add_dependency "virtus", "~> 1.0"
-  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_dependency "json", ">= 1.7"
+  spec.add_development_dependency 'bundler', '~> 1.0'
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", ">= 3.0.0.beta1"
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: undo
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Alexander Paramonov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-16 00:00:00.000000000 Z
+date: 2014-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: virtus
@@ -24,20 +24,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -68,12 +82,9 @@ dependencies:
         version: 3.0.0.beta1
 description: |2
 
-  Undo reverts operation made upon object.
-  It stores the object state before the mutator operation and allows to restore this state later.
-
-  Undo uses adapters for storage (Redis, ActiveRecord, etc) and custom serializers (ActiveRecord, Virtus, etc).
-  It is very lightweight solution that can be used as well with heavy ActiveRecord as with simple Hash or Virtus objects.
-  No database required: store data as it suites you.
+  The Undo restores previous object state.
+  Lightweight, modular and very flexible library that works as with
+  Rails, as with plain Ruby.
 email:
 - alexander.n.paramonov@gmail.com
 executables: []
@@ -90,16 +101,22 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- VERSION
 - lib/undo.rb
 - lib/undo/config.rb
+- lib/undo/container/json.rb
+- lib/undo/integration/shared_undo_integration_examples.rb
+- lib/undo/keeper.rb
 - lib/undo/serializer/null.rb
+- lib/undo/storage/adapter.rb
 - lib/undo/storage/memory.rb
 - lib/undo/version.rb
-- lib/undo/wrapper.rb
 - spec/spec_helper_lite.rb
+- spec/support/ci_helper.rb
+- spec/undo/config_spec.rb
+- spec/undo/container/json_spec.rb
 - spec/undo/serializer/null_spec.rb
 - spec/undo/storage/memory_spec.rb
-- spec/undo/wrapper_spec.rb
 - spec/undo_spec.rb
 - undo.gemspec
 homepage: http://github.com/AlexParamonov/undo
@@ -128,8 +145,10 @@ specification_version: 4
 summary: Reverts operation made upon object
 test_files:
 - spec/spec_helper_lite.rb
+- spec/support/ci_helper.rb
+- spec/undo/config_spec.rb
+- spec/undo/container/json_spec.rb
 - spec/undo/serializer/null_spec.rb
 - spec/undo/storage/memory_spec.rb
-- spec/undo/wrapper_spec.rb
 - spec/undo_spec.rb
 has_rdoc: 

data/lib/undo/wrapper.rb

@@ -1,34 +0,0 @@
-require "forwardable"
-
-module Undo
-  class Wrapper < SimpleDelegator
-    extend Forwardable
-    def_delegators :object, :class, :kind_of?
-    attr_reader :uuid
-
-    def initialize(object, options = {})
-      @object = object
-      @mutator_methods = options.delete(:mutator_methods) || []
-      @uuid = object.respond_to?(:uuid) ? object.uuid : options.fetch(:uuid)
-      @options = options
-
-      super object
-    end
-
-    def method_missing(method, *args, &block)
-      store if mutator_methods.include? method
-      super method, *args, &block
-    end
-
-    private
-    attr_reader :object, :options
-
-    def mutator_methods
-      Kernel.Array(@mutator_methods)
-    end
-
-    def store
-      Undo.store object, options.merge(uuid: uuid)
-    end
-  end
-end

data/spec/undo/wrapper_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper_lite"
-
-describe Undo::Wrapper do
-  subject { described_class }
-  let(:model) { subject.new object, uuid: uuid, mutator_methods: mutator_methods }
-  let(:mutator_methods) { [:change] }
-  let(:object) { double :object, change: true }
-  let(:uuid) { double :uuid }
-
-  describe "storage" do
-    it "stores object when mutator method is called" do
-      expect(model).to receive(:store)
-      model.change
-    end
-  end
-
-  describe "#uuid" do
-    it "uses provided uuid" do
-      expect(model.uuid).to eq uuid
-    end
-
-    describe "when object respond_to uuid" do
-      it "uses object#uuid instead" do
-        expect(object).to receive(:uuid) { "123" }
-        expect(model.uuid).to eq "123"
-        expect(Undo).to receive(:store).with(object,  hash_including(uuid: "123"))
-        model.change
-      end
-    end
-  end
-end