class_state 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 87cb7c7d36cf428d6d9189beedc5f6f07e2ee8a2
+  data.tar.gz: 7c6b831852faa2b02c5e507b5a2e908c6fcc286e
+SHA512:
+  metadata.gz: 369146d994e3f024d0402f4a8b746415a41b02019659a94346130689e9e4980346635aad180ac4f62cd3d345de74b4d57426857545b8438b68e5ea0d778aa641
+  data.tar.gz: ef2483a890b291b12d72bd614a360d06656f0d4aeb81e9fb1ce1ff2604c80ebb9c42f9cc5a03094d8f7e7927508d2a3502af218e353991cb7458875ef63e75cd

data/.gitignore

@@ -0,0 +1,38 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# debugging
+.byebug_history

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'byebug'
+end

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    class_state (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (8.2.1)
+    diff-lcs (1.2.5)
+    rake (10.5.0)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.1)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug
+  class_state!
+  rake (~> 10.5)
+  rspec (~> 3.3)
+
+BUNDLED WITH
+   1.11.2

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Mark
+
+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/Rakefile

@@ -0,0 +1,9 @@
+require 'rdoc/task'
+require "rspec/core/rake_task"
+
+task :default => :rspec do; end
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('rspec') do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end

data/class_state.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name = "class_state"
+  s.version = '0.1.0'
+  s.date = '2016-02-21'
+
+  s.files = `git ls-files`.split($/)
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rake', '~> 10.5'
+  s.add_development_dependency 'rspec', '~> 3.3'
+
+  s.author = "Mark van de Korput"
+  s.email = "dr.theman@gmail.com"
+  s.description = %q{A ruby class for managing states class-states}
+  s.summary = %q{Provides logic and a framework for thinking about the state of your classes}
+  s.homepage = %q{https://github.com/markkorput/class_state}
+  s.license = "MIT"
+end

data/lib/class_state.rb

@@ -0,0 +1,3 @@
+require 'class_state/class_state'
+require 'class_state/owner'
+

data/lib/class_state/class_state.rb

@@ -0,0 +1,150 @@
+require 'logger'
+
+class ClassState
+    attr_reader :values
+    attr_reader :callback_definitions
+
+    def initialize(_values = {})
+        @callback_definitions = []
+        self.set(_values)
+    end
+    
+    def logger
+        @_logger ||= Logger.new(STDOUT).tap do |l|
+            l.level = Logger::WARNING
+        end
+    end
+            
+        
+    # readers
+
+    def get(attr_name)
+        values[attr_name]
+    end
+    
+    def [](attr_name)
+        values[attr_name]
+    end
+    
+    def data
+        self.values
+    end
+    
+    # writers
+    
+    def []=(key, val)
+        return self.update(key => val)
+    end
+
+    def update(_values)
+        self.set(self.values.merge(_values))
+        return self
+    end
+
+    def set(_values)
+        original = self.values || {}
+        @values = _values
+        changes = get_changes_hash(original, _values)
+
+        changes.keys.each do |changed_attr|
+            trigger_attribute_callbacks(:change_attribute, changed_attr, self, changes)
+        end
+
+        if !changes.empty?
+            trigger_callbacks(:change, self, changes)
+        end
+        
+        return self
+    end
+    
+    def unset(attrs)
+        unsets = {}
+
+        [attrs].flatten.each do |attr_name|
+            if self.values.keys.include?(attr_name)
+                unsets.merge!(attr_name => self.values.delete(attr_name))
+            end
+        end
+        
+        unsets.keys.each do |changed_attr|
+            trigger_attribute_callbacks(:unset_attribute, changed_attr, self, unsets)
+        end
+
+        if !unsets.empty?
+            trigger_callbacks(:unset, self, unsets)
+        end
+
+        return unsets
+    end
+
+    def on(*args, &block)
+        callback_definition = {:event => args.first}
+
+        if block
+            callback_definition[:block] = block
+            callback_definition[:attribute] = args[1] # could be nil
+        else
+            if args.first == :change_attribute or args.first == :unset_attribute
+                callback_definition[:attribute] = args[1]
+                callback_definition[:subject] = args[2]
+                callback_definition[:method] = args[3]
+            else
+                callback_definition[:subject] = args[1]
+                callback_definition[:method] = args[2]
+            end
+        end
+
+        if callback_definition[:block].nil? and callback_definition[:method].nil?
+            logger.warn "ClassState.on didn't get a callback method or block"
+        end
+        
+        if !callback_definition[:method].nil?
+            callback_definition[:method] = callback_definition[:method].to_s.to_sym
+        end
+
+        # save definition
+        @callback_definitions << callback_definition
+    end
+    
+    private
+    
+    def get_changes_hash(before, after)
+        # assume all new values as changes, but reject the ones that are still the same as before
+        changes = after.reject do |key, value|
+            before[key] == value # new value is same as old value; don't include in 'changes' data hash
+        end
+
+        # also include the removed attributes in the changes
+        before.each_pair do |key, value|
+            if !after.keys.include?(key)
+                changes.merge!(key => nil)
+            end
+        end
+
+        return changes
+    end
+
+    def trigger_callbacks(event, *args)
+        self.callback_definitions.each do |callback_def|
+            if callback_def[:event] == event and callback_def[:attribute].nil?
+                if callback_def[:block]
+                    callback_def[:block].call(*args)
+                else
+                    callback_def[:subject].send(callback_def[:method], *args)
+                end
+            end
+        end
+    end
+
+    def trigger_attribute_callbacks(event, attr, *args)
+        self.callback_definitions.each do |callback_def|
+            if callback_def[:event] == event and callback_def[:attribute] == attr
+                if callback_def[:block].nil?
+                    callback_def[:subject].send(callback_def[:method], *args)
+                else
+                    callback_def[:block].call(*args)
+                end
+            end
+        end
+    end
+end # of class ClassState

data/lib/class_state/owner.rb

@@ -0,0 +1,63 @@
+require 'class_state/class_state'
+
+# monkey patch the Owner module insto the ClassState class scope
+class ClassState
+    module Owner
+        attr_reader :state
+
+        def self.included(cls)
+            cls.extend(ClassMethods)
+        end
+        
+        def initialize(_state_values = {})
+            @state ||= ClassState.new(_state_values)
+        end
+    
+        def method_missing(method_name, *args)
+            # byebug
+
+            if method_name =~ /=$/
+                # byebug
+                if writer = self.class.state_writers.find{|state_writer| "#{state_writer[:name]}=" == method_name.to_s}
+                    return self.state[writer[:attribute] || writer[:name]] = args.first
+                end
+                
+                # throw NoMethodError
+                return super(method_name, *args)
+            end
+
+            if reader = self.class.state_readers.find{|state_reader| state_reader[:name].to_s == method_name.to_s}
+                return self.state[reader[:attribute] || reader[:name]] || reader[:default]
+            end
+            
+            # throw NoMethodError
+            return super(method_name, *args)
+        end
+
+        module ClassMethods
+            def state_readers
+                @state_readers ||= []
+            end
+            
+            def state_writers
+                @state_writers ||= []
+            end
+                
+            def state_reader(name, opts = {})
+                state_readers << opts.merge(:name => name)
+                # self.define_method(name) do
+                #     self.state[opts[:attribute] || name] || opts[:default]
+                # end
+            end
+    
+            def state_writer(name, opts = {})
+                state_writers << opts.merge(:name => name)
+            end
+    
+            def state_accessor(name, opts = {})
+                state_readers << opts.merge(:name => name)
+                state_writers << opts.merge(:name => name)
+            end
+        end
+    end
+end

data/spec/class_state_owner_spec.rb

@@ -0,0 +1,215 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'class_state'
+
+describe ClassState::Owner do
+    let(:klass){
+        Class.new do
+            include ClassState::Owner
+        end
+    }
+
+    let(:data){
+        {:treshold => 45, :verbose => false}   
+    }
+
+    describe '.state' do
+        let(:instance){
+            klass.new(data)
+        }
+
+        it 'gives the instance\'s configuration object' do
+            expect(instance.state.class).to eq ClassState
+        end
+
+        it 'allows you to access all ClassState functionality directly on the object itself' do
+            expect(instance.state.update(:treshold => 50))
+            expect(instance.state[:treshold]).to eq 50
+            expect(instance.state.data).to eq(:treshold => 50, :verbose => false)
+        end
+    end
+
+    describe '.initialize' do
+        it 'creates a default initialize method that accepts a hash parameter with configuration values' do
+            # without 
+            expect(klass.new(:name => 'bill', :age => 45).state.data).to eq(:name => 'bill', :age => 45)
+        end
+
+        it 'configuration through initialize is optional' do
+            expect(klass.new.state.data).to eq({})
+        end
+    end
+
+    # state attribute proxy methods
+
+    describe 'self.state_reader' do
+        let(:klass){
+            Class.new do
+                include ClassState::Owner
+                state_writer :name
+            end
+        }
+        
+        let(:instance){
+            klass.new
+        }
+
+        it 'creates a state attribute-writer proxy method in the owner' do
+            expect(instance.state[:name]).to eq nil
+            instance.name = 'freddy'
+            expect(instance.state[:name]).to eq 'freddy'
+        end
+        
+        describe ':attribute option' do
+            it 'lets the caller specify a state-attribute with a different name than the setter method' do
+                klass.state_writer :age, :attribute => :value
+                instance = klass.new
+                expect(instance.state.data).to eq({})
+                instance.age = 35
+                expect(instance.state.data).to eq(:value => 35)
+            end
+        end
+    end
+
+    describe 'self.state_writer' do
+        let(:klass){
+            Class.new do
+                include ClassState::Owner
+                state_reader :name
+            end
+        }
+        
+        let(:instance){
+            klass.new
+        }
+
+        it 'creates a state attribute-writer proxy method in the owner' do
+            instance.state.set(:name => 'bobby')
+            expect(instance.name).to eq 'bobby'
+        end
+
+        describe ':attribute option' do
+            it 'lets the caller specify a state-attribute with a different name than the setter method' do
+                # expect(instance.respond_to?(:age)).to eq false
+                instance.class.state_reader :age, :attribute => :year
+                # expect(instance.respond_to?(:age)).to eq true
+                # age getter method doesn't read the age state attribute
+                instance.state.set(:age => 23)
+                expect(instance.age).to eq nil
+                # it reads the year state attribute
+                instance.state.set(:year => 24)
+                expect(instance.age).to eq 24
+            end
+        end
+        
+        describe ':default option' do
+            it 'lets the caller define a default value for when the ClassState\'s attribute is nil' do
+                # expect(instance.respond_to?(:foo)).to eq false
+                instance.class.state_reader :foo, :default => 'bar'
+                # expect(instance.respond_to?(:foo)).to eq true
+                expect(instance.state[:foo]).to eq nil # foo attribute not set in the ClassState
+                expect(instance.foo).to eq 'bar' # the getter returns the default value
+            end
+            
+            it 'plays nice with the :attribute option' do
+                # expect(instance.respond_to?(:foo)).to eq false
+                # expect(instance.respond_to?(:bar)).to eq false
+                instance.class.state_reader :foo, :attribute => :bar, :default => 'foo'
+                # expect(instance.respond_to?(:foo)).to eq true
+                # expect(instance.respond_to?(:bar)).to eq false
+                expect(instance.foo).to eq 'foo' # the getter returns the default value
+                instance.state.set(:bar => 'foobar')
+                expect(instance.foo).to eq 'foobar' # reads bar state attribute
+            end
+        end
+    end
+
+    describe 'self.state_accessor' do
+        let(:klass){
+            Class.new do
+                include ClassState::Owner
+                state_accessor :name
+            end
+        }
+        
+        let(:instance){
+            klass.new
+        }
+
+        it 'creates state attribute-reader/writer proxy methods in the owner' do
+            expect(instance.state[:name]).to eq nil
+            instance.name = 'john'
+            expect(instance.state[:name]).to eq 'john'
+            expect(instance.name).to eq 'john'
+        end
+
+        describe ':attribute option' do
+            it 'lets the caller specify a state-attribute with a different name than the method' do
+                # no accessor methods
+                # expect(instance.respond_to?(:age)).to eq false
+                # expect(instance.respond_to?(:age=)).to eq false
+                # create methods
+                instance.class.state_accessor :age, :attribute => :years_old
+                # vieryf methods
+                # expect(instance.respond_to?(:age)).to eq true
+                # expect(instance.respond_to?(:age=)).to eq true
+
+                # initial status
+                expect(instance.state[:years_old]).to eq nil
+                expect(instance.age).to eq nil
+                # update
+                instance.age = '99'
+
+                # state verifications
+                expect(instance.state[:age]).to eq nil
+                expect(instance.state[:years_old]).to eq '99'
+                # reader method verification
+                expect(instance.age).to eq '99'
+            end
+        end
+        
+        describe ':default option' do
+            it 'works like the self.state_reader :default option' do
+                instance.class.state_accessor :v1, :default => '100%'
+                expect(instance.state[:v1]).to eq nil
+                expect(instance.v1).to eq '100%'
+                instance.v1 = '200%'
+                expect(instance.v1).to eq '200%'
+            end
+            
+            it 'plays nice with the :attribute option' do
+                instance.class.state_accessor :v2, :attribute => :percentage, :default => '10%'
+                expect(instance.state[:v2]).to eq nil
+                expect(instance.state[:percentage]).to eq nil
+                expect(instance.v2).to eq '10%'
+                instance.v2 = '20%'
+                expect(instance.v2).to eq '20%'
+                expect(instance.state[:percentage]).to eq '20%'
+                expect(instance.state.data.keys.include?(:v2)).to eq false
+            end
+        end
+    end
+    
+    describe '.method_missing' do
+        let(:klass){
+            Class.new do
+                include ClassState::Owner
+                state_reader :name
+            end
+        }
+        
+        let(:instance){
+            klass.new(:name => 'doe')
+        }
+
+        it 'is used to implement state_reader/_writer/_accessor behaviour' do
+           expect(instance.respond_to?(:name)).to eq false
+           expect{ 
+               expect(instance.name).to eq 'doe'
+           }.to_not raise_error
+        end
+        
+        it 'still raises the NoMethodError when invoked incorrectly' do
+            expect{ instance.address }.to raise_error(NoMethodError)
+        end
+    end
+end

data/spec/class_state_spec.rb

@@ -0,0 +1,289 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'class_state'
+
+describe ClassState do
+    let(:instance){
+        ClassState.new
+    }
+
+    # READERS
+
+    describe ".data" do
+        it 'gives a hash with the current values' do
+            expect(instance.data).to eq({})
+        end
+    end
+
+    describe '.get' do
+        it 'gives the current value of a specified property' do
+            expect(instance.get(:name)).to eq nil
+            expect(instance.set(:name => 'billy').get(:name)).to eq 'billy'
+        end
+        
+        it 'returns nil when specified attribute is not set' do
+            expect(instance.get(:foo)).to eq nil
+        end
+    end
+
+    describe '[]' do
+        it 'gives the current value of a specified property' do
+            expect(instance[:name]).to eq nil
+            expect(instance.set(:name => 'billy')[:name]).to eq 'billy'
+        end
+        
+        it 'returns nil when specified attribute is not set' do
+            expect(instance[:foo]).to eq nil
+        end
+    end
+    
+    # WRITERS
+
+    describe '[]=' do
+        it 'updates a specified state attibute' do
+            instance = ClassState.new.update(:name => 'johnny')
+            expect(instance.data).to eq({:name => 'johnny'})
+            instance[:name] = 'cash'
+            expect(instance.data).to eq({:name => 'cash'})
+        end
+    end
+
+    describe '.update' do
+        it 'updates the current values with the given hash' do
+            instance.update(:name => 'rachel', :age => 25)
+            expect(instance.data).to eq({:name => 'rachel', :age => 25})
+            instance.update(:shoe_size => 39)
+            expect(instance.data).to eq({:name => 'rachel', :age => 25, :shoe_size => 39})
+        end
+
+        it 'supports linked notation' do
+            expect(ClassState.new.update(:name => 'johnny').update(:name => 'cool-i-o').update(:age => 20).data).to eq({:name => 'cool-i-o', :age => 20})
+        end
+    end
+
+    describe '.set' do
+        it 'sets the current values to the given hash, overwriting any current values' do
+            instance.set(:name => 'rachel', :age => 25)
+            expect(instance.data).to eq({:name => 'rachel', :age => 25})
+            instance.set(:shoe_size => 39)
+            expect(instance.data).to eq({:shoe_size => 39})
+        end
+        
+        it 'supports linked notation' do
+            expect(ClassState.new.set(:name => 'johnny').set(:name => 'cool-i-o').set(:age => 20).data).to eq({:age => 20})
+        end
+    end
+
+    describe '.unset' do
+        it 'removes a previously set attribute' do
+            instance = ClassState.new(:percentage => 65, :id => 101)
+            expect(instance.data).to eq({:percentage => 65, :id => 101})
+            expect(instance.unset(:id)).to eq({:id => 101}) # it returns a hash of removed attributes/values
+            expect(instance[:id]).to eq nil
+            expect(instance.data).to eq({:percentage => 65})
+        end
+        
+        it 'accepts an array of attribute identifiers' do
+            instance = ClassState.new(:percentage => 65, :id => 101)
+            expect(instance.data).to eq({:percentage => 65, :id => 101})
+            expect(instance.unset([:id, :percentage])).to eq({:percentage => 65, :id => 101}) # it returns a hash of removed attributes/values
+            expect(instance.data).to eq({})
+        end
+        
+        it 'ignores specified unknown attributes' do
+           instance = ClassState.new(:percentage => 65, :id => 101)
+           expect(instance.unset(:foo)).to eq({}) # :foo attribute doesn't exist
+           expect(instance.unset([:foo, :bar])).to eq({}) # :foo and :bar attributes dosn't exist
+           expect(instance.data).to eq({:percentage => 65, :id => 101}) # nothing changed
+        end
+    end
+
+    # CALLBACKS
+
+    describe '.on' do
+        describe 'general :change event' do
+            it 'accepts a block to run' do
+                # we're gonna 'record' changes into this array
+                recording = {}
+                instance.on(:change) do |state, changes|
+                    recording.merge!(changes)
+                end
+    
+                expect(recording).to eq({})
+                instance.set({:id => 123, :value => 'X'})
+                expect(recording).to eq({:id => 123, :value => 'X'})
+                instance.set({:record_id => 101})
+                expect(instance.data).to eq({:record_id => 101})
+                expect(recording).to eq({:id => nil, :value => nil, :record_id => 101})
+            end
+
+            it 'accepts a subject and method pair' do
+                # create instance of temporary dummy class with callbacker method
+                recorder = Class.new(Object) do
+                    def recording
+                        @recording ||= {}
+                    end
+
+                    def callbacker(state, changes)
+                        recording.merge!(changes)
+                    end
+                end.new
+    
+                instance.on(:change, recorder, :callbacker) # on change, call the 'callbacker' method on instance
+                expect(recorder.recording).to eq({}) # callback not triggered yet
+                instance.update(:change => 'is').update(:a => 'sound') # these trigger the callback
+                expect(recorder.recording).to eq({:change => 'is', :a => 'sound'}) # verify
+            end
+        end
+        
+        describe ':change_attribute event' do
+            it 'runs a block callback' do
+                recording = {} 
+                instance.on(:change_attribute, :id) do |state, changes|
+                    recording.merge!(changes)
+                end
+
+                expect(recording).to eq({})
+                # change id to 1
+                instance.set(:name => 'billy', :id => 1) 
+                # all changes are given in the callback
+                expect(recording).to eq({:name => 'billy', :id => 1})
+                # no changes to id
+                instance.update(:name => 'johnny')
+                expect(recording).to eq({:name => 'billy', :id => 1})
+                # change id to 2
+                instance.update(:id => 2) 
+                expect(recording).to eq({:name => 'billy', :id => 2})
+            end
+            
+            it 'triggers a specified method on a given instance' do
+                # create instance of temporary dummy class with callbacker method
+                recorder = Class.new(Object) do
+                    def recording
+                        @recording ||= {}
+                    end
+
+                    def record(state, changes)
+                        recording.merge!(changes)
+                    end
+                end.new
+                
+                # when a change to attribute 'id' happens,
+                # call method 'record' on recorder
+                instance.on(:change_attribute, :id, recorder, :record)
+
+                expect(recorder.recording).to eq({})
+                # change id to 1
+                instance.set(:name => 'billy', :id => 1) 
+                expect(recorder.recording).to eq(:name => 'billy', :id => 1)
+                # no changes to id
+                instance.update(:name => 'johnny')
+                expect(recorder.recording).to eq(:name => 'billy', :id => 1)
+                # change id to 2
+                instance.update(:id => 2)
+                expect(recorder.recording).to eq(:name => 'billy', :id => 2)
+            end
+        end
+        
+        describe 'general :unset event' do
+            let(:instance){
+                ClassState.new(:id => 101, :value => 50)
+            }
+
+            it 'takes a callback as a block' do
+                # we're gonna 'record' changes here
+                recording = {}
+
+                instance.on(:unset) do |state, unsets|
+                    recording.merge!(unsets)
+                end
+    
+                # nothing yet
+                expect(recording).to eq({})
+                # set some initial values
+                instance.update({:id => 123, :value => 'X'})
+                # callback not triggered yet
+                expect(recording).to eq({})
+                # id
+                instance.unset(:id)
+                expect(recording).to eq({:id => 123})
+                # value
+                instance.unset(:value)
+                expect(recording).to eq({:id => 123, :value => 'X'})
+                # nothing
+                instance.unset(:foo)
+                expect(recording).to eq({:id => 123, :value => 'X'})
+            end
+            
+            it 'takes a callback as a subject/method pair' do 
+                # create instance of temporary dummy class with callbacker method
+                recorder = Class.new(Object) do
+                    def recording
+                        @recording ||= {}
+                    end
+
+                    def callbacker(state, unsets)
+                        recording.merge!(unsets)
+                    end
+                end.new
+
+                instance = ClassState.new(:a => 'b', :c => 'd')
+                # on 'unset' event, call the 'callbacker' method on instance
+                instance.on(:unset, recorder, :callbacker)
+                expect(recorder.recording).to eq({}) # callback not triggered yet
+                instance.unset([:a, :c]) # trigger the callback
+                expect(recorder.recording).to eq({:a => 'b', :c => 'd'}) # verify
+            end
+        end
+
+        describe ':unset_attribute event' do
+            let(:instance){
+                ClassState.new(:id => 101, :value => 50)
+            }
+
+            it 'takes a callback as a block' do
+                # we're gonna 'record' changes to id attribute here
+                recording = {}
+
+                instance.on(:unset_attribute, :id) do |state, unsets|
+                    recording.merge!(unsets)
+                end
+    
+                # nothing yet
+                expect(recording).to eq({})
+                # set some initial values
+                instance.update({:id => 123, :value => 'X'})
+                # callback not triggered yet
+                expect(recording).to eq({})
+                # id
+                instance.unset(:id)
+                expect(recording).to eq({:id => 123})
+                # value
+                instance.unset(:value)
+                expect(recording).to eq({:id => 123})
+            end
+            
+            it 'takes a callback as a subject/method pair' do 
+                # create instance of temporary dummy class with callbacker method
+                recorder = Class.new(Object) do
+                    def recording
+                        @recording ||= {}
+                    end
+
+                    def callbacker(state, unsets)
+                        recording.merge!(unsets)
+                    end
+                end.new
+
+                instance = ClassState.new(:a => 'b', :c => 'd')
+                # when the :id attribute is unset, call the 'callbacker' method on instance
+                instance.on(:unset_attribute, :a, recorder, :callbacker)
+                expect(recorder.recording).to eq({}) # callback not triggered yet
+                instance.unset(:c) # this doesn't trigger the callback
+                expect(recorder.recording).to eq({}) # callback still not triggered
+                instance.unset(:a) # triggers the callback
+                expect(recorder.recording).to eq({:a => 'b'}) # verify
+            end
+        end
+    end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# loads and runs all tests for the rxsd project
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+require 'rspec'
+
+require 'logger'
+
+begin
+  require 'byebug'
+rescue LoadError => e
+  Logger.new(STDOUT).warn("Could not load byebug, continuing without it")
+end
+
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: class_state
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mark van de Korput
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: A ruby class for managing states class-states
+email: dr.theman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- Rakefile
+- class_state.gemspec
+- lib/class_state.rb
+- lib/class_state/class_state.rb
+- lib/class_state/owner.rb
+- spec/class_state_owner_spec.rb
+- spec/class_state_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/markkorput/class_state
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Provides logic and a framework for thinking about the state of your classes
+test_files: []