decorum 0.0.1

data/spec/support/decorations/third_decorator.rb

@@ -0,0 +1,20 @@
+module Decorum
+  module Spec
+    module Decorations
+      class ThirdDecorator < Decorum::Decorator
+        share :shared_attribute
+        attr_accessor :local_attribute
+
+        def third_decorator_method
+          "third"
+        end
+
+        alias_method :current_decorator_method, :third_decorator_method
+
+        def respect_previously_defined_methods?
+          false
+        end
+      end
+    end
+  end
+end

data/spec/support/decorator/basic_decorator.rb

@@ -0,0 +1,20 @@
+module Decorum
+  module Spec
+    module Decorator
+      class BasicDecorator < Decorum::Decorator
+        default_attributes first_default: "default value", overridden_default: false
+
+        share :shared_attribute, :unused_shared_attribute
+        attr_accessor :name, :unused_personal_attribute
+
+        def basic_decorator_method
+          true
+        end
+
+        def respect_previously_defined_methods?
+          false
+        end
+      end
+    end
+  end
+end

data/spec/support/decorator/decorated_object_stub.rb

@@ -0,0 +1,17 @@
+module Decorum
+  module Spec
+    module Decorator
+      class DecoratedObjectStub
+        include Decorum::Decorations
+        
+        def respect_previously_defined_methods?
+          true
+        end
+        
+        def decorated_state(*args)
+          @decorated_state ||= Decorum::Spec::Decorator::DecoratedStateStub.new
+        end
+      end
+    end
+  end
+end

data/spec/support/decorator/decorated_state_stub.rb

@@ -0,0 +1,11 @@
+module Decorum
+  module Spec
+    module Decorator
+      class DecoratedStateStub < Decorum::DecoratedState
+        def reaching_its_destination?
+          true
+        end
+      end
+    end
+  end
+end

data/spec/support/decorator/decorator_stub.rb

@@ -0,0 +1,11 @@
+module Decorum
+  module Spec
+    module Decorator
+      class DecoratorStub 
+        def method_missing(*args)
+          throw :deferred, self
+        end
+      end
+    end
+  end
+end

data/spec/unit/bare_particular_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Decorum::BareParticular do
+  let(:bp) { Decorum::BareParticular.new }
+  
+  it 'is decoratable' do
+    expect(bp).to be_a(Decorum::Decorations)
+  end
+
+  it 'black holes undefined methods' do
+    expect(bp.nonexistent_method).to be_nil
+  end
+end

data/spec/unit/chain_stop_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Decorum::ChainStop do
+  let(:chainstop) { Decorum::ChainStop.new }
+
+  it 'throws self via :chain_stop on undefined method' do
+    response = catch :chain_stop do 
+      chainstop.nonexistent_method
+    end
+    expect(response).to be_equal(chainstop)
+  end
+end

data/spec/unit/decorated_state_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Decorum::DecoratedState do
+  let(:ds) { Decorum::DecoratedState.new(foo: "bar") }
+  
+  it 'assigns initialized options' do
+    expect(ds.foo).to eq("bar")
+  end
+
+  context 'when forwarding messages' do
+    before(:each) do
+      # need to pop it open first...
+      fake_shared_state = Decorum::Spec::DecoratedState::SharedStateStub.new
+      ds.instance_variable_set(:@shared_state, fake_shared_state)
+    end
+
+    it 'forwards getter methods' do
+      expect(ds.marker).to eq("retrieved")
+    end
+
+    it 'forwards setter methods' do
+      expect(ds.send(:"marker=", 'foo')).to eq('assigned')
+    end
+
+    describe '#respond_to?' do
+      it 'is false for forwarded messages' do
+        expect(ds.respond_to?(:marker)).to be_false
+      end
+    end 
+  end
+end

data/spec/unit/decorations_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+
+describe Decorum::Decorations do
+  let(:decorated) { Decorum::Spec::Decorations::DecoratedObjectStub.new }
+  let(:deco_class_1) { Decorum::Spec::Decorations::FirstDecorator }
+  let(:deco_class_2) { Decorum::Spec::Decorations::SecondDecorator }
+  let(:deco_class_3) { Decorum::Spec::Decorations::ThirdDecorator }
+   
+
+  context 'as-yet-undecorated' do 
+    # assert some basic assumptions
+    it 'is decoratable' do
+      expect(decorated.is_a?(Decorum::Decorations)).to be_true
+    end
+
+    it 'does not respond to first decorator test method' do
+      expect(decorated.respond_to?(:first_decorator_method)).to be_false
+    end
+
+    it 'responds to its own methods' do 
+      expect(decorated.undecorated_method).to be_true
+    end
+
+    describe '#decorated_state' do
+      it 'returns a hash' do
+        blank_state = decorated.decorated_state
+        expect(blank_state.is_a?(Hash)).to be_true
+      end
+
+      it 'returns an empty hash' do
+        blank_state = decorated.decorated_state
+        expect(blank_state.empty?).to be_true
+      end
+
+      it 'returns nil given an argument' do
+        expect(decorated.decorated_state(:not_gonna_work)).to be_nil
+      end
+    end
+    
+    describe 'undecorate' do
+      it 'returns self on symbol' do
+        expect(decorated.undecorate(:symbol_arg)).to be_equal(decorated)
+      end
+
+      it 'returns self on spurious Decorator' do
+        expect(decorated.undecorate(deco_class_1)).to be_equal(decorated)
+      end
+    end
+  end
+
+  context 'decorated' do
+    describe '#decorate' do
+      it 'returns self on decoration' do
+        real_decorated = decorated
+        expect(decorated.decorate(deco_class_1)).to be_equal(real_decorated)
+      end
+      
+      it 'yields decorator if block_given?' do
+        decorator = nil
+        decorated.decorate(deco_class_1) { |dec| decorator = dec }
+        actual_decorator = decorated.instance_variable_get(:@_decorator_chain)
+        expect(decorator).to be(actual_decorator)
+      end
+       
+      context 'success' do 
+        before(:each) do
+          decorator_options = { decorator_handle: "first", shared_attribute: "shared 1", local_attribute: "local 1" }
+          decorated.decorate(deco_class_1, decorator_options)
+        end
+
+        it 'installs intercept' do
+          expect(decorated.is_a?(Decorum::Decorations::Intercept)).to be_true
+        end
+
+        it 'sets internal state' do
+          internal_state = decorated.instance_variable_get(:@_decorator_chain)
+          expect(internal_state.is_a?(deco_class_1)).to be_true
+        end
+
+        it 'does not lose its own methods' do
+          expect(decorated.respect_previously_defined_methods?).to be_true
+        end
+        
+        it 'gains the methods of the decorator' do
+          expect(decorated.first_decorator_method).to eq('first')
+        end
+
+        it 'raises NoMethodError on nonexistent method' do
+          expect { decorated.nonexistent_method }.to raise_error(NoMethodError)
+        end
+        
+        it 'is decorated by local attributes' do
+          expect(decorated.local_attribute).to eq("local 1")
+        end
+
+        it 'is decorated by shared attributes' do
+          expect(decorated.shared_attribute).to eq("shared 1")
+        end
+
+        it 'creates decorated state for decorator class' do
+          expect(decorated.decorated_state(deco_class_1).shared_attribute).to eq('shared 1')
+        end
+      
+        context 'with multiple decorators' do
+          before(:each) do
+            3.times do |i|
+              klass = send(:"deco_class_#{i + 1}")
+              decorated.decorate(klass)
+            end
+          end
+
+          it 'retains decorated methods' do
+            responses = [:first, :second, :third].map do |prefix|
+              decorated.send(:"#{prefix}_decorator_method") 
+            end
+            expect(responses).to eq(["first", "second", "third"])
+          end
+          
+          it 'prefers the most recent decorator' do
+            expect(decorated.current_decorator_method).to eq("third")
+          end
+        end
+      end
+
+      context 'failure' do
+        it 'rejects classes that are not Decorators' do
+          expect { decorated.decorate(Class,{}) }.to raise_error(RuntimeError)
+        end
+
+        it 'rejects non unique decorator handles' do
+          3.times do |i|
+            klass = send(:"deco_class_#{i + 1}")
+            decorated.decorate(klass, decorator_handle: "deco-#{i + 1}")
+          end
+          expect { decorated.decorate(deco_class_1, decorator_handle: "deco-2") }.to raise_error(RuntimeError)
+        end
+      end
+    end
+    
+    describe '#respond_to?' do
+      before(:each) { decorated.decorate(deco_class_1) }
+
+      it 'returns true for decorated methods' do  
+        expect(decorated.respond_to?(:first_decorator_method)).to be_true
+      end
+
+      it 'returns true for undecorated methods' do
+        expect(decorated.respond_to?(:undecorated_method)).to be_true
+      end
+
+      it 'returns false for undefined method' do
+        expect(decorated.respond_to?(:nonexistent_method)).to be_false
+      end
+    end
+
+    context 'monitoring and unloading' do
+      before(:each) do
+        3.times do |x|
+          klass = send(:"deco_class_#{x + 1}")
+          decorated.decorate(klass, decorator_handle: "deco-#{x + 1}")
+        end
+      end
+
+      describe '#decorators' do
+        it 'accurately reflects loaded decorators and in order' do
+          expected_map = ["deco-3", "deco-2", "deco-1"]
+          expect(decorated.decorators.map { |d| d.decorator_handle }).to eq(expected_map)
+        end
+
+        it 'memoizes decorators' do
+          decorated.decorators[0].next_link = decorated.decorators[2]
+          expect(decorated.decorators.length).to be(3)
+        end
+
+        it 'refreshes via #decorators!' do
+          decorated.decorators[0].next_link = decorated.decorators[2]
+          decorated.send(:decorators!)
+          expect(decorated.decorators.length).to be(2)
+        end
+      end
+
+      describe '#undecorate' do 
+        before(:each) do
+          @undec = decorated.decorators.detect { |d| d.decorator_handle == "deco-2" }
+          # just to make sure...
+          unless @undec.is_a?(Decorum::Decorator)
+            raise "broken test---no such decorator deco-2; undec was #{@undec.inspect}"
+          end
+        end
+
+        it 'undecorates' do
+          decorated.undecorate(@undec)
+          expect(decorated.decorators.length).to be(2)
+        end
+
+        it 'undecorates the right one' do
+          decorated.undecorate(@undec)
+          expected_map = ["deco-3", "deco-1"]
+          expect(decorated.decorators.map { |d| d.decorator_handle }).to eq(expected_map)
+        end
+
+        it 'returns self on success' do
+          real_decorated = decorated
+          expect(decorated.undecorate(@undec)).to be_equal(real_decorated)
+        end
+        
+        context 'once undecorated' do
+          before(:each) { decorated.undecorate(@undec) }
+
+          it 'no longer responds to removed decorated method' do
+            expect(decorated.respond_to?(:second_decorator_method)).to be_false
+          end
+
+          it 'still responds to other decorated methods' do 
+            expect(decorated.respond_to?(:third_decorator_method)).to be_true
+          end
+
+          it 'doesn\'t mind if we check one just to be sure' do
+            expect(decorated.first_decorator_method).to eq('first')
+          end
+
+          it 'destroys shared state when last class member is gone' do
+            expect(decorated.decorated_state(deco_class_2)).to be_nil
+          end
+
+          it 'does not destroy other shared state' do
+            expect(decorated.decorated_state(deco_class_1)).to be_a(Decorum::DecoratedState)
+          end
+        end 
+      end
+    end
+  end
+end

data/spec/unit/decorator_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe Decorum::Decorator do
+  let(:decorator) do 
+    @next_link = Decorum::ChainStop.new
+    @root = Decorum::Spec::Decorator::DecoratedObjectStub.new
+    @options_for_decorator = { name: 'bob', shared_attribute: 'shared', overridden_default: true }
+    Decorum::Spec::Decorator::BasicDecorator.new(@next_link, @root, @options_for_decorator)
+  end
+
+  it 'responds to .share' do
+    expect(Decorum::Decorator.respond_to?(:share)).to be_true
+  end
+
+  it 'responds to .accumulator' do
+    expect(Decorum::Decorator.respond_to?(:accumulator)).to be_true
+  end
+  
+  describe '#decorated_state' do
+    it 'defers to the root object' do
+      expect(decorator.decorated_state.reaching_its_destination?).to be_true  
+    end
+  end
+
+  describe '#next_link' do  
+    it 'returns the next decorator' do
+      expect(decorator.next_link).to be_equal(@next_link)
+    end
+  end
+
+  describe '#next_link=' do
+    it 'sets the next decorator' do
+      @new_next_link = Decorum::Spec::Decorator::DecoratorStub.new
+      decorator.next_link = @new_next_link
+      response = catch :deferred do 
+        decorator.send(:nonexistent_method)
+      end
+
+      expect(response).to be_equal(@new_next_link)
+    end
+
+  describe '#root' do
+    it 'returns the root object' do
+      expect(decorator.root).to be_equal(@root)
+    end
+
+    it 'is aliased as #object' do
+      expect(decorator.object).to be_equal(@root)
+    end
+  end
+
+  describe '#
+
+  describe '#decorated_tail' do
+    let(:value) { "howdy" } 
+    
+    it 'catches :chain_stop' do
+      response = decorator.decorated_tail(value) { throw :chain_stop, "caught" }
+      expect(response).to eq("caught")
+    end
+
+    it 'preserves return value' do 
+      response = decorator.decorated_tail(value) { decorator.send(:nonexistent_method) }
+      expect(response).to eq(value)
+    end
+  end
+  
+  context 'when attributes are declared default' do
+    describe '#getter' do
+      it 'gets default value' do
+        expect(decorator.first_default).to eq("default value")
+      end
+      
+      it 'is overridden by options passed to initialize' do
+        expect(decorator.overridden_default).to equal(true)
+      end
+    end
+    
+    describe '#setter' do 
+      it 'gets defined' do
+        decorator.first_default = "new value"
+        expect(decorator.first_default).to eq("new value")
+      end
+    end
+  end
+        
+  context 'when attributes are declared via share' do
+    describe '#setter' do
+      it 'does not set attribute locally' do
+        expect(decorator.instance_variable_get(:@shared_attribute)).to be_nil
+      end
+
+      it 'sets attribute in shared state' do 
+        expect(decorator.decorated_state.shared_attribute).to eq('shared')
+      end
+    end
+
+    describe '#getter' do
+      it 'sets attribute' do
+        expect(decorator.shared_attribute).to eq('shared')
+      end
+
+      it 'gets nil for unused attribute' do
+        expect(decorator.unused_shared_attribute).to be_nil
+      end
+    end
+
+    describe '#boolean' do
+      it 'returns true on set attribute' do
+        expect(decorator.shared_attribute?).to equal(true)
+      end
+
+      it 'returns false on unset attribute' do
+        expect(decorator.unused_shared_attribute?).to equal(false)
+      end
+    end
+
+    describe '#resetter' do
+      before(:each) { decorator.reset_shared_attribute }
+     
+      it 'sets attribute to nil' do
+        expect(decorator.shared_attribute).to be_nil
+      end
+
+      it 'sets attribute to nil in shared state' do
+        decorator.instance_variable_set(:@shared_attribute, "for real not nil")
+        expect(decorator.shared_attribute).to be_nil
+      end
+    end 
+  end
+
+  context 'when attributes via declared personally' do
+    describe '#setter' do
+      it 'sets local attribute via initialize' do
+        expect(decorator.name).to eq('bob')
+      end
+    
+      it 'sets local attribute locally by initialize' do
+        expect(decorator.instance_variable_get(:@name)).to eq('bob')
+      end
+
+      it 'does not set local attribute in shared state via initialize' do
+        expect(decorator.decorated_state.name).to be_nil
+      end
+    end
+
+    describe '#getter' do
+      it 'gets nil for unused attribute' do
+        expect(decorator.unused_personal_attribute).to be_nil
+      end
+    end
+  end
+  
+  context 'when calling decorator methods' do
+    it 'picks up methods it has' do
+      expect(decorator.basic_decorator_method).to be_true
+    end
+
+    it 'defers methods it doesn\'t have' do
+      response = catch :chain_stop do 
+        decorator.send(:nonexistent_method) 
+      end
+      expect(response).to be_a(Decorum::ChainStop)
+    end
+  end
+end