decorum 0.2.0 → 0.3.0

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - jruby-head
+  - ruby-head
+  - 1.9.3
+  - 2.0.0

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 0.3.0 / 2014-2-3
+
+* [FEATURE] directly callable decorators
+* [FEATURE] decorator namespaces
+* [FEATURE] set superhash class from environment variables
+* [FEATURE] immediate all
+* [FEATURE] #post_decorate
+* a more nuanced position on the immediacy issue, etc. (see README)
+
 # 0.2.0 / 2014-01-18
 
 * [FEATURE] support/tests for immediate methods

data/README.md

@@ -1,4 +1,6 @@
 # Decorum
+[![Gem Version](https://badge.fury.io/rb/decorum.png)](http://badge.fury.io/rb/decorum)
+[![Build Status](https://travis-ci.org/erikcameron/decorum.png?branch=master)](https://travis-ci.org/erikcameron/decorum)
 
 Decorum implements lightweight decorators
 for Ruby, called "tasteful decorators." (See below.)  It is very small,
@@ -6,6 +8,7 @@ possibly very fast, and has no requirements outside of the standard
 library.  Use it wherever.
 
 ## Quick Start
+
 ```ruby
 gem install decorum
 
@@ -24,12 +27,20 @@ bp.respond_to?(:shoot_confetti) # ==> false
 bp.decorate(Confetti)
 bp.shoot_confetti # ==> "boom, yay"
 ```
+
+## New in 0.3.0
+- Methods may be called directly on decorators
+- Decorator namespaces
+- Set superhash and shared state classes via environment
+- Entire decorator interfaces may be declared `immediate` (see below)
+- #post_decorate callback
+
 ## About
 
 [Skip to the action](#usage)
 
 Decorum expands on the traditional Decorator concept by satisfying [a few additional 
-contraints](#tasteful_decorators). The constraints are designed to make decorators' role in your 
+contraints](#tasteful-decorators). The constraints are designed to make decorators' role in your 
 overall object structure both clear and safe. More on these points below.
 
 - Object Identity: After you decorate an object, you're still dealing with that same
@@ -41,13 +52,13 @@ the decorated object's public methods. (Though you can instruct it to.) This is
 
 By adhering to these constraints, decorators tend to do the Right Thing, i.e, integrate into existing
 applications easily, and stay out of the way when they aren't doing your bidding. Hence "[tasteful
-decorators](#tasteful_decorators)." (Not meant to imply others are tacky. The name just stuck.)
+decorators](#tasteful-decorators)." (Not meant to imply others are tacky. The name just stuck.)
 
 In addition, Decorum provides a few helpful features:
 
 - Stackable decorators, with shared state 
 - Recursion, via `#decorated_tail`
-- Intercept/change messages
+- Intercept/change/reroute messages, a la Chain of Reponsibility
 - Build stuff entirely out of decorators
 
 As an example of how this is in use right now, suppose you're interfacing a content
@@ -58,16 +69,17 @@ on the image at runtime, e.g.,:
 
 ```ruby
 image_collection = Application::ImageData.sidebar_images
-# say this returns a hash keyed by identifier:
-# { blah: { url: 'http://blah.foo/', alt: 'The Blah Conglomerate' ... }}
 images = Cms::Images.where(identifier: image_collection.keys)
+# ==> { blah: { url: 'http://blah.foo/', alt: 'The Blah Conglomerate' ... }}
 
 images.each do |img|
   img.decorate(ImageMetaDecorator, image_collection[img.identifier])
 end
 
+# defined in ImageMetaDecorator:
 images[0].url # ==> 'http://blah.foo'
 images[0].alt # ==> 'The Blah Conglomerate'
+images[0].fetch_thumbnail_or_queue_to_create
 ```
 
 ### Isn't a Decorator like a Presenter which is like an HTML macro?
@@ -87,15 +99,15 @@ Decorators may or may not present.
 Like "traditional" (i.e., [Gang of Four](http://en.wikipedia.org/wiki/Design_Patterns)-style)
 decorator patterns, Decorum is a general purpose, object-oriented tool. Use it wherever.
 
-### <a name="#tasteful_decorators"></a>Tasteful Decorators
+### Tasteful Decorators
 
 #### Object Identity
 
 Decorators, as conceived of by GoF, Python, etc., masquerade as the
 objects they decorate by responding to their interface. They are _not_ the
 original objects themselves. This may or may not be a problem, depending
-on how your app is structured. In general though, (I doubt this is news)
-it risks breaking encapsulation. Any code which stores direct references
+on how your code is structured. In general though, (I doubt this is news)
+it risks breaking encapsulation: Any code which stores direct references
 to the original object will have to update them to get the decorated
 behavior.  For example, in a common Rails idiom, in order to do this:
 
@@ -142,14 +154,20 @@ and state stays where it should.
 #### Defers to the original interface
 
 Unless instructed otherwise, Decorum will not override existing methods
-on the decorated object. In practice, this might be useful, (see below
-for how to instruct it otherwise) but from a design standpoint, it
-looks to me like an anti-pattern.  The fact that the method _needs_
-overriding implies the original object doesn't have the relevant state to
-fulfill it. The method is now spread out over two classes, that of the original
-object and that of the decorator. 
-
-The paradigm cases of decorators don't generally address this, either. Consider three
+on the decorated object. (See below for how to instruct it otherwise.)
+There are certainly cases where this is useful, and having come across
+one myself since the 0.2.0 release, I've amended my position slightly. But
+not much.
+
+I'm suspicious of this practice, as it blurs the line between
+"decorating" an object and straight-up monkey patching it.  The fact that the method
+_needs_ overriding implies the original object doesn't have the relevant
+state to fulfill it. The method is now spread out over two classes,
+that of the original object and that of the decorator. This may be
+unavoidable, or monkey patching may be your intention---in that case,
+by all means. But I don't think it's a pattern to be designed to.
+
+The paradigm cases of decorators don't generally address overriding either. Consider three
 common examples:
 
 - Adding a scrollbar to a window
@@ -163,7 +181,8 @@ but it's by no means an essential use of the pattern. And from a design
 perspective, it's a red flag that concerns are becoming... unseparated.
 (It also risks weird bugs by breaking transparency, i.e., you can have
 cases where `a` and `b` are literally identical, but have different 
-attributes.)
+attributes.) With Decorum, you can implement that entire domain of behavior,
+possibly using a [namespace](#namespaced-decorators).
 
 When an object is decorated, Decorum inserts its own `#method_missing`
 and `#respond_to_missing?` into the object's eigenclass. Decorum's `#method_missing`
@@ -182,17 +201,18 @@ message, `super` is called and lookup proceeds normally.
 
 #### Unloadable decorators
 
-Decorators can be unloaded, if necessary. (The following case illustrates
-this, and the need for callbacks, e.g., `#after_decorate`. Definitely one
-my next priorities.)
+Decorators can be unloaded, if necessary:
 
 ```ruby
 @bob.decorate(IsTheMole)
 @bob.revoke_security_clearances 
-# ideally this would be called automatically by IsTheMole
-# on decoration
 
 class IsTheMole < Decorum::Decorators
+  # callback
+  def post_decorate
+    object.revoke_security_clearances
+  end
+
   def revoke_security_clearances
     clearances = object.decorators.select { |d| d.is_a?(SecurityClearance) }
     clearances.each { |clearance| object.undecorate(clearance) }
@@ -213,13 +233,13 @@ which would be significantly slower.)
 
 See the source for more details.
 
-## <a name="usage"></a> Usage
+## Usage
 
 First, objects need to be decoratable. You can do this for a whole class,
 by including Decorum::Decorations, or for a single object, by extending it.
 (Note: this alone doesn't change the object's method lookup. It just makes
 `#decorate` available on the object. The behavior is only changed when
-`#decorate` is called.) The easiest method is probably including 
+`#decorate` is called.) The easiest way is probably including 
 Decorum::Decorations at whatever point(s) of the class hierarchy you
 feel appropriate.
 
@@ -296,14 +316,12 @@ are shared among all decorators of that class on a given object:
 if an object has three MilkDecorators, the `#milk_level`/`#milk_level=` methods
 literally access the same state on all three.
 In addition, you get `#milk_level?` and `#reset_milk_level` to
-perform self-eviYou can insert this at whatever point in the dent functions.
+perform self-evident functions.
 
 Access to the shared state is proxied first through the root object,
 and then through an instance of Decorum::DecoratedState, before
-ultimately pointing to an instance of Decorum::SuperHash. (SuperHash
-is used for a few things---see the source. It's
-normally OpenStruct, to limit Decorum's dependencies to the standard
-library, but you can override it; I use Hashr personally.) 
+ultimately pointing to an instance of Decorum::SharedState. This
+class can be set via the environment (see lib/decorum.rb).
 
 In the examples above and below, shared state is mainly used to
 accumulate results, like in `#milk_level`. It can also be used for 
@@ -421,6 +439,39 @@ You can now parameterize your responses based on whatever conditions you like,
 by loading different decorators before the request is serviced. If nobody claims
 the specialized method, your default will be returned instead.
 
+### Calling decorators directly
+
+An object's decorators are available via `#decorators`, or by passing a block to `#decorate`:
+
+```ruby
+@object.decorate(SomeDecorator) { |dec| @this_decorator = dec }
+@object.decorators # <== array of decorators
+
+# start a request in the middle of the decorator chain:
+@the_decorator_im_looking_for = @object.decorators.detect { |d| d.name == "cool decorator, bro" }
+@the_decorator_im_looking_for.some_method
+```
+
+(Note that these methods pass the decorator(s) back wrapped in Decorum::CallableDecorator, 
+which is necessary to call methods on them directly.)
+
+### Namespaced Decorators
+
+As noted above, overriding an objects public methods breaks behavior over two 
+different classes. To package a domain of behavior in a namespace using Decorum:
+
+```ruby
+@request.decorate(MyRouter, namespace: "routes")
+@request.routes.my_route(path: "foo/bar")
+# namespaces pass anything they can't do back to the root
+# object, so they effectively override it:
+@request.routes.defined_on_request_object? # <== true
+```
+
+This way, you don't have to define a `#my_route` stub on the original class for
+undecorated instances, and the public method of the original object is available
+on (and in) the namespace.
+
 ### Overriding existing methods
 
 To give decorator methods preference over an objects existing methods (if you
@@ -441,6 +492,9 @@ x.decorate(StrongWilledDecorator)
 x.method_in_question # <== "overridden"
 ```
 
+If you declare `immediate` with no arguments, the decorators entire public interface
+is used. 
+
 ### Decorators All the Way Down
 
 Decorum includes a class called Decorum::BareParticular, which descends from
@@ -452,10 +506,8 @@ return nil by default.
 
 ## To-do
 A few things I can imagine showing up soon:
-- Probably the most important thing is before/after callbacks for decoration
-  and undecoration.
-- Namespaced decorators, probably showing up as a method on the root object,
-  e.g., `object.my_namespace.namespaced_method`
+- An easy way to alias the main methods (#decorate, #undecorate), as you might
+  want those names for something else.
 - Thread safety: probably not an issue if you're retooling your Rails helpers,
   but consider a case like this:
 
@@ -468,12 +520,11 @@ A few things I can imagine showing up soon:
     end
   end
 ```
-- Easy subclassing of Decorum::DecoratedState, so you can do wacky things with it
 
 &c. I'm open to suggestion.
  
 ## Contributing
-I wrote most of this super late at night, (don't worry, the tests pass) so that would be awesome:
+I wrote most of this super late at night, (don't worry, the tests pass!) so that would be awesome:
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)

data/Rakefile

@@ -1 +1,4 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/examples/immediate_decorator.rb

@@ -0,0 +1,22 @@
+module Decorum
+  module Examples
+    class ImmediateDecorator < Decorum::Decorator
+      immediate 
+      share :immediately_shared
+
+      def method_in_question
+        "overridden"
+      end
+      
+      def another_method_in_question
+        "overridden"
+      end
+
+      def increment_immediately_shared
+        self.immediately_shared ||= 0
+        self.immediately_shared += 1
+        decorated_tail(immediately_shared) { next_link.increment_immediately_shared }
+      end
+    end
+  end
+end

data/lib/decorum.rb

@@ -1,14 +1,39 @@
+# decorum.rb
 require 'ostruct'
 
-module Decorum
-  # or Hashr, or whatever---just run the test suite
-  class SuperHash < OpenStruct
+superhash_class = if class_name = ENV['DECORUM_SUPERHASH_CLASS']
+  current = nil
+  class_name.split('::').each do |const_name|
+    modyool  = current || Kernel
+    current  = modyool.const_get(const_name)
+  end
+  current
+else
+  OpenStruct
+end
+
+shared_state_class = if class_name = ENV['DECORUM_SHARED_STATE_CLASS']
+  current = nil
+  class_name.split('::').each do |const_name|
+    modyool  = current || Kernel
+    current  = modyool.const_get(const_name)
   end
+  current
+else
+  superhash_class
 end
 
-require "decorum/version"
-require 'decorum/decorations'
-require 'decorum/decorator'
-require 'decorum/decorated_state'
-require 'decorum/chain_stop'
-require 'decorum/bare_particular'
+module Decorum
+end
+
+Decorum::SuperHash    = superhash_class
+Decorum::SharedState  = shared_state_class
+
+require_relative 'decorum/version'
+require_relative 'decorum/decorations'
+require_relative 'decorum/decorator'
+require_relative 'decorum/decorated_state'
+require_relative 'decorum/chain_stop'
+require_relative 'decorum/bare_particular'
+require_relative 'decorum/callable_decorator'
+require_relative 'decorum/decorator_namespace'

data/lib/decorum/callable_decorator.rb

@@ -0,0 +1,18 @@
+module Decorum
+  class CallableDecorator
+    def initialize(decorator)
+      @_decorator = decorator
+    end
+    
+    def method_missing(message, *args, &block)
+      response = catch :chain_stop do
+        @_decorator.send(message, *args, &block)
+      end
+      if response.is_a?(Decorum::ChainStop)
+        @_decorator.root.send(message, *args, &block)
+      else
+        response
+      end
+    end
+  end
+end

data/lib/decorum/decorated_state.rb

@@ -1,7 +1,7 @@
 module Decorum
   class DecoratedState 
     def initialize(options={})
-      @shared_state = Decorum::SuperHash.new(options)
+      @shared_state = Decorum::SharedState.new(options)
     end
 
     # this is one of two areas---the other being

data/lib/decorum/decorations.rb

@@ -1,9 +1,33 @@
 module Decorum
   module Decorations
     def decorate(klass, options={})
-      extend Decorum::Decorations::Intercept
-      decorator = add_to_decorator_chain(klass, options)
-      yield decorator if block_given?
+      if namespace_method = options.delete(:namespace)
+        decorator = nil
+        namespace = nil
+        if self.respond_to?(namespace_method)
+          namespace = send(namespace_method)
+          unless namespace.is_a?(Decorum::DecoratorNamespace)
+            raise RuntimeError, "#{namespace_method} exists and is not a decorator namespace"
+          end
+          namespace.decorate(klass, options) { |d| decorator = d }
+        else
+          namespace = Decorum::DecoratorNamespace.new(self)
+          namespace.decorate(klass, options) { |d| decorator = d }
+          instance_variable_set(:"@_decorum_#{namespace_method}", namespace)
+          m = Module.new do
+            define_method(namespace_method) do
+              instance_variable_get(:"@_decorum_#{namespace_method}")
+            end
+          end
+          extend m
+        end
+        yield CallableDecorator.new(decorator) if block_given?
+      else
+        extend Decorum::Decorations::Intercept
+        decorator = add_to_decorator_chain(klass, options)
+        yield CallableDecorator.new(decorator) if block_given?
+        decorator.post_decorate
+      end 
       self
     end
 
@@ -12,7 +36,15 @@ module Decorum
       self
     end
 
+    
+    # returns callable decorators---use this
     def decorators
+      _decorators.map { |d| CallableDecorator.new(d) }
+    end
+
+    # returns raw decorators---don't use this unless
+    # you know what you're doing
+    def _decorators
       if @_decorators
         return @_decorators
       elsif !@_decorator_chain
@@ -28,6 +60,12 @@ module Decorum
       @_decorators
     end
 
+    # reset the decorator collection
+    def _decorators!
+      @_decorators = nil
+      _decorators
+    end
+
     def decorated_state(klass=nil)
       @_decorated_state ||= {}
 
@@ -47,7 +85,7 @@ module Decorum
       end
       
       def respond_to_missing?(message, include_private = false)
-        decorators.each { |d| return true if d.respond_to?(message) }
+        _decorators.each { |d| return true if d.respond_to?(message) }
         super
       end
     end
@@ -56,14 +94,13 @@ module Decorum
 
     def add_to_decorator_chain(klass, options)
       unless klass.ancestors.include?(Decorum::Decorator)
-        raise RuntimeError.new("decorator chain needs a Decorator")
+        raise RuntimeError, "decorator chain needs a Decorator"
       end
 
       if options[:decorator_handle]
-        current_names = decorators.map { |d| d.decorator_handle.to_sym }.compact
+        current_names = _decorators.map { |d| d.decorator_handle.to_sym }.compact
         if current_names.include?(options[:decorator_handle].to_sym)
-          # is this a little harsh?
-          raise RuntimeError.new("decorator names must be unique over an object")
+          raise RuntimeError, "decorator names must be unique over an object"
         end
       end
 
@@ -87,30 +124,30 @@ module Decorum
         end
         extend immediate
       end
-
-      decorators!
+      _decorators!
       @_decorator_chain
     end
 
     def remove_from_decorator_chain(decorator)
-      return nil unless decorator.is_a?(Decorum::Decorator) && decorators.include?(decorator) 
+      if decorator.is_a?(CallableDecorator) 
+        decorator = decorator.instance_variable_get(:@_decorator)
+      end
+
+      unless (decorator.is_a?(Decorum::Decorator) && _decorators.include?(decorator))
+        return nil
+      end
 
       if decorator == @_decorator_chain
         @_decorator_chain = decorator.next_link
       else
-        previous_decorator = decorators[decorators.index(decorator) - 1]
+        previous_decorator = _decorators[_decorators.index(decorator) - 1]
         previous_decorator.next_link = decorator.next_link
       end
       
-      unless decorators!.map { |d| d.class }.include?(decorator.class)
+      unless _decorators!.map { |d| d.class }.include?(decorator.class)
         @_decorated_state[decorator.class] = nil
       end
-      decorators
-    end
-
-    def decorators!
-      @_decorators = nil
-      decorators
+      _decorators
     end
   end
 end

data/lib/decorum/decorator.rb

@@ -20,6 +20,11 @@ module Decorum
         end
       end
     end
+    
+    # override if you want
+    def post_decorate
+      nil
+    end
 
     # a superhash of shared state between Decorators
     # of the same class
@@ -37,6 +42,7 @@ module Decorum
       end
       response.is_a?(Decorum::ChainStop) ? current_value : response
     end
+    alias_method :defer, :decorated_tail
 
     # delegate to next_link
     # note that we are not faking #respond_to? because
@@ -82,13 +88,19 @@ module Decorum
       end
       
       # allow Decorator classes to override the decorated object's
-      # public methods (tsk tsk)
+      # public methods; use with no args to declare the entire interface 
       def immediate(*method_names)
-        @immediate_methods ||= []
-        @immediate_methods += method_names
+        if method_names.empty?
+          @all_immediate = true
+        else
+          @immediate_methods ||= []
+          @immediate_methods += method_names
+        end
       end
 
-      attr_reader :immediate_methods
+      def immediate_methods
+        @all_immediate ? instance_methods(false) : (@immediate_methods || [])
+      end
     end
   end
 end

data/lib/decorum/decorator_namespace.rb

@@ -0,0 +1,13 @@
+module Decorum
+  class DecoratorNamespace
+    include Decorum::Decorations
+
+    def initialize(root_object)
+      @_root_object = root_object
+    end
+
+    def method_missing(message, *args, &block)
+      @_root_object.send(message, *args, &block)
+    end
+  end
+end

data/lib/decorum/version.rb

@@ -1,3 +1,3 @@
 module Decorum
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/spec/integration/immediate_methods_spec.rb

@@ -30,4 +30,14 @@ describe "When overriding original methods with .immediate" do
     base_object.undecorate(base_object.decorators.first)
     expect(base_object.second_immediate_method).to eq("class method_missing")
   end
+
+  it "recurses" do
+    4.times { base_object.decorate(Decorum::Examples::ImmediateDecorator) }
+    expect(base_object.increment_immediately_shared).to eq(4)
+  end
+
+  it "recurses on namespaced decorator" do
+    4.times { base_object.decorate(Decorum::Examples::ImmediateDecorator, namespace: :foo) }
+    expect(base_object.foo.increment_immediately_shared).to eq(4)
+  end
 end

data/spec/support/decorations/first_decorator.rb

@@ -4,6 +4,7 @@ module Decorum
       class FirstDecorator < Decorum::Decorator
         share :shared_attribute
         attr_accessor :local_attribute
+        attr_reader :post_decorated
 
         def first_decorator_method
           "first"
@@ -14,6 +15,10 @@ module Decorum
         def respect_previously_defined_methods?
           false
         end
+        
+        def post_decorate
+          @post_decorated = "decorated"
+        end
       end
     end
   end

data/spec/support/decorator/chatty_root_object_stub.rb

@@ -0,0 +1,11 @@
+module Decorum
+  module Spec
+    module Decorator
+      class ChattyRootObjectStub 
+        def method_missing(*args)
+          "root"
+        end
+      end
+    end
+  end
+end

data/spec/unit/callable_decorator_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Decorum::CallableDecorator do
+  let(:decorator) do 
+    c = Decorum::Examples::Coffee.new
+    decorator = nil
+    c.decorate(Decorum::Examples::MilkDecorator) { |d| decorator = d }
+    decorator
+  end
+
+  it "enables methods to be called directly on decorators" do
+    decorator.add_milk
+    expect(decorator.root.milk_level).to eq(1)
+  end
+
+  context "testing assumptions" do
+    # just make sure we did this right...
+    it "is a Decorator" do
+      expect(decorator.is_a?(Decorum::CallableDecorator)).to be_true
+    end
+  end
+end

data/spec/unit/decorations_spec.rb

@@ -5,7 +5,6 @@ describe Decorum::Decorations do
   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
@@ -54,12 +53,16 @@ describe Decorum::Decorations do
         real_decorated = decorated
         expect(decorated.decorate(deco_class_1)).to be_equal(real_decorated)
       end
+
+      it 'calls #post_decorate' do
+        expect(decorated.decorate(deco_class_1).post_decorated).to eq("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)
+        expect(decorator.instance_variable_get(:@_decorator)).to be(actual_decorator)
       end
        
       context 'success' do 
@@ -173,8 +176,8 @@ describe Decorum::Decorations do
         end
 
         it 'refreshes via #decorators!' do
-          decorated.decorators[0].next_link = decorated.decorators[2]
-          decorated.send(:decorators!)
+          decorated._decorators[0].next_link = decorated._decorators[2]
+          decorated.send(:_decorators!)
           expect(decorated.decorators.length).to be(2)
         end
       end
@@ -183,7 +186,7 @@ describe Decorum::Decorations do
         before(:each) do
           @undec = decorated.decorators.detect { |d| d.decorator_handle == "deco-2" }
           # just to make sure...
-          unless @undec.is_a?(Decorum::Decorator)
+          unless @undec.is_a?(Decorum::CallableDecorator)
             raise "broken test---no such decorator deco-2; undec was #{@undec.inspect}"
           end
         end

data/spec/unit/decorator_namespace_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Decorum::DecoratorNamespace do
+  let(:root)          { Decorum::Spec::Decorator::DecoratedObjectStub.new }
+  let(:chatty_root)   { Decorum::Spec::Decorator::ChattyRootObjectStub.new }
+  let(:ns_class)      { Decorum::DecoratorNamespace }
+
+  it "is decoratable" do
+    ns = ns_class.new(root)
+    expect(ns.is_a?(Decorum::Decorations)).to be_true
+  end
+  
+  it "defers to root object on unknown messages" do
+    ns = ns_class.new(chatty_root)
+    expect(ns.asdfasdfadf).to eq("root")
+  end
+end

data/spec/unit/decorator_spec.rb

@@ -197,5 +197,12 @@ describe Decorum::Decorator do
       got_em = methods.map { |m| Decorum::Examples::StrongWilledDecorator.immediate_methods.include?(m) }.inject(:&)
       expect(got_em).to be_true
     end
+   
+    context 'with no arguments' do
+      it 'immediafies its whole public interface' do
+        deco_class = Decorum::Examples::ImmediateDecorator
+        expect(deco_class.immediate_methods).to eq(deco_class.instance_methods(false))
+      end
+    end
   end
 end

data/spec/unit/superhash_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Decorum::SuperHash do
+  let(:soop) { Decorum::SuperHash.new(a: "z", b: "y", c: "x") }
+
+  it "accepts a hash" do
+    expect(soop.a).to eq("z")
+  end
+  
+  it "returns nil on nonexistent methods" do
+    expect(soop.asdfasdfasd).to be_nil
+  end
+  
+  context "after initialization" do
+    it "has working setters" do
+      soop.d = "w"
+      expect(soop.d).to eq("w")
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: decorum
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-19 00:00:00.000000000 Z
+date: 2014-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,6 +67,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -75,16 +76,19 @@ files:
 - decorum.gemspec
 - examples/coffee.rb
 - examples/fibonacci_decorator.rb
+- examples/immediate_decorator.rb
 - examples/milk_decorator.rb
 - examples/strong_willed_decorator.rb
 - examples/sugar_decorator.rb
 - examples/weak_willed_class.rb
 - lib/decorum.rb
 - lib/decorum/bare_particular.rb
+- lib/decorum/callable_decorator.rb
 - lib/decorum/chain_stop.rb
 - lib/decorum/decorated_state.rb
 - lib/decorum/decorations.rb
 - lib/decorum/decorator.rb
+- lib/decorum/decorator_namespace.rb
 - lib/decorum/version.rb
 - spec/integration/coffee_spec.rb
 - spec/integration/fibonacci_spec.rb
@@ -96,14 +100,18 @@ files:
 - spec/support/decorations/second_decorator.rb
 - spec/support/decorations/third_decorator.rb
 - spec/support/decorator/basic_decorator.rb
+- spec/support/decorator/chatty_root_object_stub.rb
 - spec/support/decorator/decorated_object_stub.rb
 - spec/support/decorator/decorated_state_stub.rb
 - spec/support/decorator/decorator_stub.rb
 - spec/unit/bare_particular_spec.rb
+- spec/unit/callable_decorator_spec.rb
 - spec/unit/chain_stop_spec.rb
 - spec/unit/decorated_state_spec.rb
 - spec/unit/decorations_spec.rb
+- spec/unit/decorator_namespace_spec.rb
 - spec/unit/decorator_spec.rb
+- spec/unit/superhash_spec.rb
 homepage: http://erikcameron.github.io/
 licenses:
 - MIT
@@ -141,11 +149,15 @@ test_files:
 - spec/support/decorations/second_decorator.rb
 - spec/support/decorations/third_decorator.rb
 - spec/support/decorator/basic_decorator.rb
+- spec/support/decorator/chatty_root_object_stub.rb
 - spec/support/decorator/decorated_object_stub.rb
 - spec/support/decorator/decorated_state_stub.rb
 - spec/support/decorator/decorator_stub.rb
 - spec/unit/bare_particular_spec.rb
+- spec/unit/callable_decorator_spec.rb
 - spec/unit/chain_stop_spec.rb
 - spec/unit/decorated_state_spec.rb
 - spec/unit/decorations_spec.rb
+- spec/unit/decorator_namespace_spec.rb
 - spec/unit/decorator_spec.rb
+- spec/unit/superhash_spec.rb