observable_object 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 849657362f62135a7a2070a2a75b2e06290a7a40
+  data.tar.gz: 94c856a7f9dae40da13a877fa13f2acb53b9a94d
+SHA512:
+  metadata.gz: f343ec8238c760e0c6fbc10240ae581247b0c7dbea5552ed8383135e01e16b2d7b4ea30b5f3a4f4d46c00989d5d999b3693329b730c029845aa89460d43806d3
+  data.tar.gz: 58b714b0e9ef908c0b632a1f9b1b21f13573b9756eaf2b18bc840c67151aec08022283aec620abfd769b3da93ec657418c5aa7fedc063d729f11689f068a739a

data/.gitignore

@@ -0,0 +1,25 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.env
+.rspec
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+**/.DS_Store

data/.hound.yml

@@ -0,0 +1,11 @@
+ruby:
+  enabled: true
+  # config_file: config/.rubocop.yml
+  
+coffee_script:
+  enabled: true
+  # config_file: config/.coffeelint.json
+  
+# java_script:
+#   enabled: true
+#   config_file: config/.jshint.json

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+cache: bundler
+
+rvm:
+  - 2.1.2
+
+branches:
+  only:
+    - master
+
+script: bundle exec rake spec
+
+before_install:
+  - gem update --system
+  - gem --version

data/CONTRIBUTORS.md

@@ -0,0 +1 @@
+* Andrey Pronin <moonfly.msk@gmail.com> aka moonfly (https://github.com/moonfly)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in observable_object.gemspec
+gemspec

data/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014 [CONTRIBUTORS.md](https://github.com/moonfly/observable_object/master/CONTRIBUTORS.md)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,120 @@
+# ObservableObject
+
+This gem provides a delegator class that wraps around an object and triggers events on modification of that object. 
+It is useful for objects that serve as accessors to external storage - when an modification to the object should trigger
+the database update, for example.
+
+One example of a gem that benefits from ObservableObject is [store_complex](https://github.com/moonfly/store_complex).
+
+[![Build Status](https://travis-ci.org/moonfly/observable_object.svg?branch=master)](https://travis-ci.org/moonfly/observable_object)
+[![Coverage Status](https://img.shields.io/coveralls/moonfly/observable_object.svg)](https://coveralls.io/r/moonfly/observable_object?branch=master)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'observable_object'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install observable_object
+
+## Usage
+
+### Shallow wrapper
+
+Create an ObservableObject for your existing object using this syntax:
+
+```ruby
+ObservableObject.wrap(your_object[, list_of_methods], &event_callback)
+```
+
+Here:
+
+- `your_object` is the object that you need to wrap
+- `list_of_methods` (optional) is the list of your object's methods that change its internal state and should lead to triggering the event
+- `event_callback` is the block to be called when the object is modified, it accepts a single parameter - the object itself
+
+The resulting object is a thin delegator around your object, so the ObservableObject will behave almost exactly as your object. That includes results of such methods as `class`, `hash`, `<=>`. It is still a separate object, so it will have it's own `__id__`, and `eql?` will act accordingly. Here is an example:
+
+```ruby
+s = ObservableObject.wrap("some string",[:capitalize!,:downcase!]) do |obj|
+  puts "The observed string is now #{obj}"
+end
+
+s.class             # => String
+s == 'some string'  # => true
+h = {}
+h[s] = 100500
+h['some string']    # => 100500
+
+s.capitalize!       # Will print "The observed string is now Some string"
+```
+
+#### Special options for the list of methods
+
+It is also possible to pass `:detect` in place of the list of methods that change the internal state. In this case `ObservableObject` will try to auto-detect such methods. That is also the default behavior. If you don't provide the second parameter, this auto-detection method will be used. Auto-detection works as follows:
+
+- It considers the state-changing methods of widely-used classes to be state-changing for this object as well. The widely used classes include `Array`, `Hash`, `Set`, `String`. Please note that `ObservableObject` knows only about the standard methods provided by Ruby. If you have your custom methods defined for these widely-used classes they will not be recognized by the observing wrapper as something that changes the object's state.
+- It considers all methods with a `!` at the end as changing the internal state.
+
+Besides auto-detection, there is another method that attempts to automatically determine if the object has changed. It relies on making a clone of an object (using `clone` method) before calling any method and then comparing this copied object with the resulting object after the method call (using `eql?`). This method can be invoked by providing `:compare` in place of the list of methods that change the internal state. Please note that this method has obvious drawbacks and limitations: 
+
+- it relies on the assumption that cloning the object doesn't have side effects and doesn't change its internal state
+- it relies on the `eql?` operator to compare the object internal states rather than checking the objects' identity
+- it has additional performance drawbacks as cloning an object (especially a complex on) takes time and memory
+
+Bottomline: know your object before you wrap it in `ObservableObject` and think several times before using it with 
+something complex when a mere operation of cloning an object may have side effects.
+
+### Deep wrapper
+
+In addition to the shallow wrapper (`ObservableObject.wrap`) this gem also provides a deep wrapper: `ObservableObject.deep_wrap`.
+A deep wrapper not only wraps the object itself, but in case of Hashes, Arrays, Sets goes ahead and wraps each of its elements in an ObservableObject. Moreover, it repeats the deap wrapping on all nested Arrays, Hashes and Sets. Regardless of which of the nested wrapped object has caused the event, the upper-level object will always be passed as the parameter to the event handler block.
+
+For deeply-wrapped objects the following situations will also trigger events:
+
+```ruby
+arr = ObservableObject.deep_wrap([[1,2,3],{a:10,b:10},"string"]) do |obj|
+  # Here obj is always arr, never a nested wrapped object
+  puts "Event triggered on #{obj}!"
+end
+
+arr[0][0] = 100       # Triggers an event
+arr[0].push(7)        # Triggers an event
+arr[1].merge!({c:50}) # Triggers an event
+arr[2].upcase!        # Triggers an event
+```
+
+Please note that there is a certain additional performance penalty if using deep wrapping since the object is re-wrapped after 
+every method that changes its internal state. This re-wrapping is done because methods like `<<` and `unshift` can add new 
+nested objects that must be wrapped.
+
+## Versioning
+
+Semantic versioning (http://semver.org/spec/v2.0.0.html) is used. 
+
+For a version number MAJOR.MINOR.PATCH, unless MAJOR is 0:
+
+1. MAJOR version is incremented when incompatible API changes are made,
+2. MINOR version is incremented when functionality is added in a backwards-compatible manner, 
+3. PATCH version is incremented when backwards-compatible bug fixes are made.
+
+Major version "zero" (0.y.z) is for initial development. Anything may change at any time. 
+The public API should not be considered stable. 
+
+## Dependencies
+
+- Ruby >= 2.1
+
+## Contributing
+
+1. Fork it ( https://github.com/moonfly/observable_object/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc "Run RSpec tests (use rake spec SPEC_OPTS='...' to pass rspec options)"
+RSpec::Core::RakeTask.new(:spec)

data/lib/observable_object.rb

@@ -0,0 +1,131 @@
+require "observable_object/version"
+
+module ObservableObject
+  class Notifier
+    def initialize(param,&event)
+      @param = param
+      @event = event
+    end
+    def call
+      @event.call(@param)
+    end
+  end
+
+  module DeepWrap
+    def self.map_obj(obj,notifier)
+      case obj
+        when Array then obj.map { |x| wrap_elem(x,notifier) }
+        when Set then obj.clone.map! { |x| wrap_elem(x,notifier) }
+        when Hash then obj.map { |k,v| [ k, wrap_elem(v,notifier) ] }.to_h
+        else obj
+      end 
+    end
+
+    NonWrappable = [Symbol, Numeric, TrueClass, FalseClass, NilClass]
+    def self.is_unwrappable(elem)
+      NonWrappable.any? { |t| elem.is_a?(t) }
+    end
+    def self.wrap_elem(elem,notifier)
+      is_unwrappable(elem) ? elem : Wrapper.new(elem,:detect,true,notifier)
+    end
+  end
+
+  module Watcher
+    class WatcherDetect
+      DefaultMethods = [  :<<, :[]=, :add, :add?, :capitalize!, :chomp!, :chop!, :clear, :collect!, :compact!, :concat, 
+                          :delete, :delete!, :delete?, :delete_at, :delete_if, :downcase!, :encode!, :gsub!, :fill, 
+                          :flatten!, :initialize_copy, :insert, :keep_if, :lstrip!, :map!, :merge!, :next!, :pop, :prepend, 
+                          :push, :rehash, :reject!, :replace, :reverse!, :rotate!, :rstrip!, :scrub!, :select!, 
+                          :shift, :shuffle!, :slice!, :sort!, :sort_by!, :squeeze!, :store, :strip!, :sub!, :subtract,
+                          :succ!, :swapcase!, :tr!, :tr_s!, :uniq!, :unshift, :upcase!, :update ]
+      StringExceptionMethods = [ :delete ]  # doesn't change the object in case of String
+
+      def initialize(obj)
+        @methods = obj.is_a?(String) ? DefaultMethods-StringExceptionMethods : DefaultMethods
+      end
+      def remember
+        # nothing to do
+      end
+      def is_state_changing(obj,mname)
+        mname.match(/.+\!\z/) || @methods.include?(mname)
+      end
+    end
+    
+    class WatcherMethods
+      def initialize(methods)
+        @methods = methods
+      end
+      def remember
+        # nothing to do
+      end
+      def is_state_changing(obj,mname)
+        @methods.include?(mname)
+      end
+    end
+    
+    class WatcherCompare
+      def remember
+        obj = yield
+        @obj_before = obj.clone rescue obj
+      end
+      def is_state_changing(obj,mname)
+        !obj.eql?(@obj_before)
+      end
+    end
+
+    def self.create(obj,methods)
+      case methods
+        when :detect then WatcherDetect.new(obj)
+        when :compare then WatcherCompare.new
+        else WatcherMethods.new(methods)
+      end
+    end
+  end
+  
+  class Wrapper < BasicObject
+    def initialize(obj,methods,deep,notifier=nil,&event)
+      @deep = deep
+      @notifier = notifier || Notifier.new(self,&event)
+      @watcher = Watcher::create(obj,methods)
+      @obj = @deep ? DeepWrap::map_obj(obj,@notifier) : obj
+    end
+    
+    def ==(other)
+      @obj == other
+    end
+    def eql?(other)
+      @obj.eql?(other)
+    end
+    def !=(other)
+      @obj != other
+    end
+    def !
+      !@obj
+    end
+
+    def respond_to?(mname)
+      @obj.respond_to?(mname)
+    end
+    def method_missing(mname,*args,&block)
+      @watcher.remember { @obj }
+
+      res = @obj.__send__(mname,*args,&block)
+      chain = @obj.equal?(res)                # did the wrapped object return itself from this method?
+      
+      if @watcher.is_state_changing(@obj,mname)
+        @obj = DeepWrap::map_obj(@obj,@notifier) if @deep # remap; some nested objects could have changed
+        @notifier.call 
+      end
+      
+      chain ? self : res                      # for chaining return self when the underlying object returns self
+    end
+  end
+  
+  # Main API
+  def self.wrap(obj,methods=:detect,&event)
+    DeepWrap.is_unwrappable(obj) ? obj : Wrapper.new(obj,methods,false,nil,&event)
+  end
+  def self.deep_wrap(obj,methods=:detect,&event)
+    DeepWrap.is_unwrappable(obj) ? obj : Wrapper.new(obj,methods,true,nil,&event)
+  end
+end

data/lib/observable_object/version.rb

@@ -0,0 +1,3 @@
+module ObservableObject
+  VERSION = "0.1.1"
+end

data/observable_object.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'observable_object/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'observable_object'
+  spec.version       = ObservableObject::VERSION
+  spec.authors       = ['moonfly (Andrey Pronin)']
+  spec.email         = ['moonfly.msk@gmail.com']
+  spec.summary       = %q{Thin delegator that wraps objects and triggers events on modification (useful for storage accessor objects)}
+  spec.description   = %q{Thin delegator that wraps objects and triggers events on modification (useful for storage accessor objects).}
+  spec.homepage      = 'https://github.com/moonfly/observable_object'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+  
+  spec.rdoc_options = ['--charset=UTF-8']
+  spec.extra_rdoc_files = %w[README.md CONTRIBUTORS.md LICENSE.md]
+  
+  spec.required_ruby_version = '>= 2.1.0'
+  
+  spec.add_development_dependency 'bundler', '>= 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'coveralls'
+end

data/spec/observable_object/deep_wrap_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe ObservableObject::DeepWrap do
+  class TestNotificationStatus
+    attr_reader :count
+    def initialize
+      @count = 0
+    end
+    def notify
+      @count += 1
+    end
+    def notified?
+      count > 0
+    end
+  end
+  
+  let(:notification_status) { TestNotificationStatus.new }
+  let(:notifier) { ObservableObject::Notifier.new(notification_status) { |param| param.notify } }
+
+  it 'keeps wrapped elements equal to original elems' do
+    ObservableObjectTest::AllObjects.each do |original|
+      expect(ObservableObject::DeepWrap.map_obj(original,notifier)).to eq(original)
+    end
+  end
+  
+  it 'wraps elements of Array' do
+    original = ["string", [1,2,3]]
+    wrapped = ObservableObject::DeepWrap.map_obj(original,notifier)
+
+    wrapped[0][0] = 'S' # should notify
+    expect(notification_status.count).to eq(1)
+
+    wrapped[1] << 5 # should notify
+    expect(notification_status.count).to eq(2)
+  end
+
+  it 'wraps elements of Hash' do
+    original = {a: "string", b: [1,2,3]}
+    wrapped = ObservableObject::DeepWrap.map_obj(original,notifier)
+
+    wrapped[:a][0] = 'S' # should notify
+    expect(notification_status.count).to eq(1)
+
+    wrapped[:b] << 5 # should notify
+    expect(notification_status.count).to eq(2)
+  end
+
+  it 'wraps elements of Set' do
+    original = Set[[1,2,3],{0=>1,1=>2}] # note: strings are frozen, don't use them in Set testing
+    wrapped = ObservableObject::DeepWrap.map_obj(original,notifier)
+
+    wrapped.each do |elem| 
+      elem[0] = 'A' # should notify
+    end
+    expect(notification_status.count).to eq(original.size)
+  end
+
+  it 'does not wrap Strings' do
+    original = "string"
+    wrapped = ObservableObject::DeepWrap.map_obj(original,notifier)
+
+    wrapped[0] = 'S' # should not notify
+    expect(notification_status.count).to eq(0)
+  end
+
+  it 'deep wraps Arrays' do
+    original = []
+    original[0] = []
+    original[0][0] = []
+    original[0][0][0] = []
+    original[0][0][0][0] = []
+    original[0][0][0][0][0] = "string"
+    wrapped = ObservableObject::DeepWrap.map_obj(original,notifier)
+
+    wrapped[0][0][0][0][0][0] = 'S'
+    expect(notification_status.count).to eq(1)
+  end
+  
+  it 'deep wraps Hashes' do
+    original = {}
+    original[:a] = {}
+    original[:a][:a] = {}
+    original[:a][:a][:a] = {}
+    original[:a][:a][:a][:a] = {}
+    original[:a][:a][:a][:a][:a] = "string"
+    wrapped = ObservableObject::DeepWrap.map_obj(original,notifier)
+
+    wrapped[:a][:a][:a][:a][:a][0] = 'S'
+    expect(notification_status.count).to eq(1)
+  end
+  
+  it 'deep wraps Sets' do
+    original = Set[Set[Set[{a:100}]]]
+    wrapped = ObservableObject::DeepWrap.map_obj(original,notifier)
+
+    wrapped.each do |x|     # x = Set[Set[{a:100}]]
+      x.each do |y|         # y = Set[{a:100}]
+        y.each do |z|       # z = {a:100}
+          z[:a] = 200
+        end
+      end
+    end
+    
+    expect(notification_status.count).to eq(1)
+  end
+  
+
+end

data/spec/observable_object/notifier_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe ObservableObject::Notifier do
+  it 'calls the specified event with the specified param' do
+    param = "some parameter"
+    called_with = nil
+    notifier = ObservableObject::Notifier.new(param) do |p|
+      called_with = p
+    end
+    expect(called_with).to be(nil)
+    expect{notifier.call}.not_to raise_error
+    expect(called_with).to be(param)
+  end
+end

data/spec/observable_object/watcher/watcher_compare_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe ObservableObject::Watcher::WatcherCompare do
+  let(:obj) { [10,30,20] }
+  let(:watcher) { ObservableObject::Watcher::WatcherCompare.new }
+  it 'returns true when object changes' do
+    watcher.remember { obj }
+    obj[0] = 100
+    expect(watcher.is_state_changing(obj,:any_method)).to be_truthy
+  end
+  it 'works with un-cloneable objects' do
+    [nil,true,false,123,3.1415,:symbol].each do |x|
+      watcher.remember { x }
+      expect(watcher.is_state_changing(x,:any_method)).to be_falsy
+    end
+  end
+  it 'returns false for a different but equal object' do
+    watcher.remember { obj }
+    expect(watcher.is_state_changing(obj.clone,:any_method)).to be_falsy
+  end
+  it 'returns false for the same object' do
+    watcher.remember { obj }
+    expect(watcher.is_state_changing(obj,:sort!)).to be_falsy
+  end
+end

data/spec/observable_object/watcher/watcher_detect_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe ObservableObject::Watcher::WatcherDetect do
+  let(:obj_str) { "String" }
+  let(:obj_arr) { [1,2,3] }
+  let(:watcher_str) { ObservableObject::Watcher::WatcherDetect.new(obj_str) }
+  let(:watcher_arr) { ObservableObject::Watcher::WatcherDetect.new(obj_arr) }
+
+  it 'ignores the block passed to remember' do
+    called = false
+    watcher_str.remember { called = true }
+    expect(called).to be false
+  end
+  it 'returns true when delete_at is called for an object' do
+    expect(watcher_str.is_state_changing(obj_str,:delete_at)).to be_truthy
+    expect(watcher_arr.is_state_changing(obj_arr,:delete_at)).to be_truthy
+  end
+  it 'returns true when delete is called for non-String objects' do
+    expect(watcher_arr.is_state_changing(obj_arr,:delete)).to be_truthy
+  end
+  it 'returns false when delete is called for String objects' do
+    expect(watcher_str.is_state_changing(obj_str,:delete)).to be_falsy
+  end
+  it 'returns true when a method with a bang is called for an object' do
+    expect(watcher_str.is_state_changing(obj_str,:scary!)).to be_truthy
+    expect(watcher_arr.is_state_changing(obj_arr,:scary!)).to be_truthy
+  end
+  it 'returns true when some other method is called for an object' do
+    expect(watcher_str.is_state_changing(obj_str,:something)).to be_falsy
+    expect(watcher_arr.is_state_changing(obj_arr,:something)).to be_falsy
+  end
+end

data/spec/observable_object/watcher/watcher_methods_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe ObservableObject::Watcher::WatcherMethods do
+  class TestWatcherMethodsObject
+    # safe methods
+    def safe; false; end
+    def safe!; false; end
+    def delete_at; false; end
+    def sort!; false; end
+    
+    # changing methods
+    def changing1; true; end
+    def changing2; true; end
+    def delete; true; end
+    def collect!; true; end
+  end
+  
+  test_methods = (TestWatcherMethodsObject.instance_methods - Object.instance_methods).map do |name|
+    [name, TestWatcherMethodsObject.new.send(name)]
+  end.to_h
+  safe_methods = test_methods.select { |k,v| v == false }.map(&:first)
+  changing_methods = test_methods.select { |k,v| v == true }.map(&:first)
+  
+  let(:obj) { TestWatcherMethodsObject.new }
+  let(:watcher) { ObservableObject::Watcher::WatcherMethods.new(changing_methods) }
+  
+  it 'ignores the block passed to remember' do
+    called = false
+    watcher.remember { called = true }
+    expect(called).to be false
+  end
+  it 'returns true when called with methods from the list' do
+    changing_methods.each do |mname|
+      expect(watcher.is_state_changing(obj,mname)).to be_truthy
+    end
+  end
+  it 'returns false when called with methods not from the list' do
+    safe_methods.each do |mname|
+      expect(watcher.is_state_changing(obj,mname)).to be_falsy
+    end
+  end
+end

data/spec/observable_object/watcher_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe ObservableObject::Watcher do
+  it 'creates the right subclass' do
+    expect(ObservableObject::Watcher.create(Hash.new,:detect)).to be_instance_of(ObservableObject::Watcher::WatcherDetect)
+    expect(ObservableObject::Watcher.create(Hash.new,:compare)).to be_instance_of(ObservableObject::Watcher::WatcherCompare)
+    expect(ObservableObject::Watcher.create(Hash.new,[])).to be_instance_of(ObservableObject::Watcher::WatcherMethods)
+  end
+end
+

data/spec/observable_object/wrapper_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe ObservableObject::Wrapper do
+  let(:event_obj_list) { Array.new }
+  let(:event) { Proc.new { |obj| event_obj_list << obj } }
+  let(:notifier) { ObservableObject::Notifier.new("notifier",&event) }
+  
+  it 'is "equal to" the original object' do
+    ObservableObjectTest::AllObjects.each do |obj|
+      wrapped = ObservableObject::Wrapper.new(obj,:compare,true,nil) { |p| ; }
+      expect(wrapped).to eq(obj)
+    end
+  end
+  it 'can be used as a key in Hashes instead of the original object' do
+    hash = Hash.new
+    ObservableObjectTest::HashKeyObjects.each do |obj|
+      # puts "-> #{obj}"
+      wrapped = ObservableObject::Wrapper.new(obj,:compare,true,nil) { |p| ; }
+      expect(wrapped.hash).to eq(obj.hash)
+      expect(wrapped.eql?(obj)).to be true
+
+      hash[obj] = obj.__id__
+      expect(hash[wrapped]).to eq(obj.__id__)
+    end
+  end
+  
+  it 'does not call events when the object is not modified' do
+    obj = [[1,2,3],[4,5,6]]
+    wrapped = ObservableObject::Wrapper.new(obj,:detect,false,nil,&event)
+    wrapped.flatten
+    expect(event_obj_list.count).to eq(0)
+  end
+  it 'calls event when the object is modified' do
+    obj = [[1,2,3],[4,5,6]]
+    wrapped = ObservableObject::Wrapper.new(obj,:detect,false,nil,&event)
+    wrapped.flatten!
+    expect(event_obj_list.count).to eq(1)
+    expect(event_obj_list.all? { |x| x == wrapped }).to be true
+  end
+  it 'calls notifier when the object is modified if notifier is provided' do
+    obj = [[1,2,3],[4,5,6]]
+    wrapped = ObservableObject::Wrapper.new(obj,:detect,false,notifier)
+    wrapped.flatten!
+    expect(event_obj_list.count).to eq(1)
+    expect(event_obj_list.all? { |x| x == "notifier" }).to be true
+  end
+  it 'calls doesn not event when sub-objects are modified (deep=false)' do
+    obj = [[1,2,3],[4,5,6]]
+    wrapped = ObservableObject::Wrapper.new(obj,:detect,false,nil,&event)
+    wrapped[0].sort!
+    expect(event_obj_list.count).to eq(0)
+  end
+  it 'calls event when sub-objects are modified (deep=true)' do
+    obj = [[1,2,3],[4,5,6]]
+    wrapped = ObservableObject::Wrapper.new(obj,:detect,true,nil,&event)
+    wrapped[0].sort!
+    expect(event_obj_list.count).to eq(1)
+    expect(event_obj_list.all? { |x| x == wrapped }).to be true
+  end
+  
+end

data/spec/observable_object_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe ObservableObject do
+  let(:event_obj_list) { Array.new }
+  let(:event) { Proc.new { |obj| event_obj_list << obj } }
+
+  it 'has version (smoke test)' do
+    expect(ObservableObject::VERSION).to be_a(String)
+  end
+  it 'returns the object itself for unwrappable objects' do
+    [:symbol, 1, 1.0, true, false, nil].each do |obj|
+      expect(ObservableObject.wrap(obj).__id__).to eq(obj.__id__)
+      expect(ObservableObject.deep_wrap(obj).__id__).to eq(obj.__id__)
+    end
+  end
+  
+  it 'is "equal to" the original object (wrap)' do
+    ObservableObjectTest::NonBasicObjects.each do |obj|
+      wrapped = ObservableObject.wrap(obj) { |p| ; }
+      expect(wrapped).to eq(obj)
+    end
+  end
+  it 'is "equal to" the original object (deep_wrap)' do
+    ObservableObjectTest::NonBasicObjects.each do |obj|
+      wrapped = ObservableObject.deep_wrap(obj) { |p| ; }
+      expect(wrapped).to eq(obj)
+    end
+  end
+
+  it 'provides correct "!" operator' do
+    ObservableObjectTest::NonBasicObjects.each do |obj|
+      wrapped = ObservableObject.wrap(obj) { |p| ; }
+      expect(!wrapped).to eq(!obj)
+    end
+  end
+  it 'provides correct "!=" operator' do
+    ObservableObjectTest::NonBasicObjects.each do |obj|
+      wrapped = ObservableObject.wrap(obj) { |p| ; }
+      expect(wrapped != obj).to be false
+    end
+  end
+  it 'provides correct methods' do
+    ObservableObjectTest::NonBasicObjects.each do |obj|
+      # puts "-> #{obj}" 
+      wrapped = ObservableObject.wrap(obj) { |p| ; }
+      
+      expect(obj.class.instance_methods.all? do |mname| 
+        # puts "----> #{mname}" 
+        wrapped.respond_to?(mname) == obj.respond_to?(mname)
+      end).to be true
+    end
+  end
+
+  it 'can be used as a key in Hashes instead of the original object (wrap)' do
+    hash = Hash.new
+    ObservableObjectTest::NonBasicObjects.each do |obj|
+      # puts "-> #{obj}"
+      wrapped = ObservableObject.wrap(obj) { |p| ; }
+      expect(wrapped.hash).to eq(obj.hash)
+      expect(wrapped.eql?(obj)).to be true
+
+      hash[obj] = obj.__id__
+      expect(hash[wrapped]).to eq(obj.__id__)
+    end
+  end
+  it 'can be used as a key in Hashes instead of the original object (deep_wrap)' do
+    hash = Hash.new
+    ObservableObjectTest::NonBasicObjects.each do |obj|
+      # puts "-> #{obj}"
+      wrapped = ObservableObject.deep_wrap(obj) { |p| ; }
+      expect(wrapped.hash).to eq(obj.hash)
+      expect(wrapped.eql?(obj)).to be true
+
+      hash[obj] = obj.__id__
+      expect(hash[wrapped]).to eq(obj.__id__)
+    end
+  end
+  
+  it 'calls event handler when the object is modified' do
+    obj = [[1],[2]]
+    wrapped = ObservableObject.deep_wrap(obj,&event)
+    wrapped[0] << 100
+    wrapped[0] << 50
+    wrapped[0].sort!
+    expect(event_obj_list.count).to eq(3)
+    expect(event_obj_list.all? { |x| x == wrapped }).to be true
+  end
+
+  it 'calls event handler after a sub-object is replaced and then modified' do
+    obj = [[1],[2]]
+    wrapped = ObservableObject.deep_wrap(obj,&event)
+    wrapped[0] = [3]
+    wrapped[0] << 50
+    wrapped[0].sort!
+    wrapped[1] = [['a','b'],'c']
+    wrapped[1][0][1] = 'd'
+    expect(event_obj_list.count).to eq(5)
+    expect(event_obj_list.all? { |x| x == wrapped }).to be true
+  end
+
+  it 'calls event handler after a sub-object is added and then modified' do
+    obj = [[1],[2]]
+    wrapped = ObservableObject.deep_wrap(obj,&event)
+    wrapped[1] << ['a','b']
+    wrapped[1].last.push('c')
+    expect(event_obj_list.count).to eq(2)
+    expect(event_obj_list.all? { |x| x == wrapped }).to be true
+  end
+  
+  # TODO: fix the case below, if there is an efficient solution. Not a bug, annoyance.
+  # it 'does not call event handler after an already deleted sub-object is modified' do
+  #   obj = [[1,2],[3,4]]
+  #   wrapped = ObservableObject.deep_wrap(obj,&event)
+  #   a = wrapped[0]
+  #   a.compact!
+  #   wrapped.delete_at(0)
+  #   a[0] = 100
+  #   expect(event_obj_list.count).to eq(2)
+  #   expect(event_obj_list.all? { |x| x == wrapped }).to be true
+  # end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'observable_object'
+
+module ObservableObjectTest
+  BasicObjects = [ BasicObject.new ]
+  DelegatorObjects = [ SimpleDelegator.new("string"), SimpleDelegator.new(1.0) ]
+
+  # NOTE: using wrapped objects as keys doesn't work for Floats and Symbols, althouth works for Fixnums, Rationals, Strings, etc!
+  # NOTE: one way hash key equivalency only, we don't patch eql? in other classes
+  NonHashKeyObjects = [ 0.0, 3.1415926, :symbol ]
+  
+  HashKeyObjects = [
+    [1,2,"3"],
+    {a:1,"a"=>1,1=>2,"1"=>"2"},
+    Set['x','y','z'],
+    "Some string",
+    %w(Array of strings),
+    [:one, :two, :three],
+    true,
+    false,
+    nil,
+    "",
+    1.0.to_c,
+    1.0.to_r,
+    [nil],
+    [],
+    Hash.new,
+    Set.new,
+    0,
+    123,
+    1234567890987654321,
+    StringIO.new("String IO"),
+    Exception.new("Some exception"),
+    Object.new,
+    Class.new,  
+    Module.new,
+    lambda { 10 },
+    Proc.new { |x| x },
+    Mutex.new,
+    [ [1,2,3], "bebe", {"key"=>"value", key: :value}, Time.now, -> { puts "Line" }, Set['a','c'] ],
+    Time.now,
+    ENV,
+    ARGV
+  ]
+  NonBasicObjects = HashKeyObjects + NonHashKeyObjects
+  AllObjects = NonBasicObjects + BasicObjects + DelegatorObjects
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: observable_object
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- moonfly (Andrey Pronin)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Thin delegator that wraps objects and triggers events on modification
+  (useful for storage accessor objects).
+email:
+- moonfly.msk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- CONTRIBUTORS.md
+- LICENSE.md
+files:
+- ".gitignore"
+- ".hound.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- CONTRIBUTORS.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/observable_object.rb
+- lib/observable_object/version.rb
+- observable_object.gemspec
+- spec/observable_object/deep_wrap_spec.rb
+- spec/observable_object/notifier_spec.rb
+- spec/observable_object/watcher/watcher_compare_spec.rb
+- spec/observable_object/watcher/watcher_detect_spec.rb
+- spec/observable_object/watcher/watcher_methods_spec.rb
+- spec/observable_object/watcher_spec.rb
+- spec/observable_object/wrapper_spec.rb
+- spec/observable_object_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/moonfly/observable_object
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Thin delegator that wraps objects and triggers events on modification (useful
+  for storage accessor objects)
+test_files:
+- spec/observable_object/deep_wrap_spec.rb
+- spec/observable_object/notifier_spec.rb
+- spec/observable_object/watcher/watcher_compare_spec.rb
+- spec/observable_object/watcher/watcher_detect_spec.rb
+- spec/observable_object/watcher/watcher_methods_spec.rb
+- spec/observable_object/watcher_spec.rb
+- spec/observable_object/wrapper_spec.rb
+- spec/observable_object_spec.rb
+- spec/spec_helper.rb