decorum 0.0.1

data/examples/milk_decorator.rb

@@ -0,0 +1,29 @@
+module Decorum
+  module Examples
+    class MilkDecorator < Decorum::Decorator
+      share :milk_level, :calories
+      attr_accessor :animal, :milk_type
+
+      # recursive function to allow all MilkDecorators to add
+      # some milk; note the tail call is wrapped in decorated_tail
+      def add_milk
+        self.milk_level = milk_level.to_i + 1
+        decorated_tail(milk_level) { next_link.add_milk }
+      end
+      
+      # used with non-shared attributes, (e.g., "animal")
+      # decorated tail can also be used to defer a
+      # call to the _first_ decorator in the chain 
+      # that responds to the method
+      def first_animal
+        decorated_tail(animal) { next_link.first_animal }
+      end
+
+      # for goodness' sake what has bob been putting in his coffee
+      def all_animals(animals=[])
+        animals << animal
+        decorated_tail(animals) { next_link.all_animals(animals) }
+      end
+    end
+  end
+end

data/examples/sugar_decorator.rb

@@ -0,0 +1,12 @@
+module Decorum
+  module Examples
+    class SugarDecorator < Decorum::Decorator
+      share :sugar_level
+
+      def add_sugar
+        self.sugar_level = sugar_level.to_i + 1
+        decorated_tail(sugar_level) { decoratee.add_cube }
+      end
+    end
+  end
+end

data/lib/decorum.rb

@@ -0,0 +1,14 @@
+require 'ostruct'
+
+module Decorum
+  # or Hashr, or whatever---just run the test suite
+  class SuperHash < OpenStruct
+  end
+end
+
+require "decorum/version"
+require 'decorum/decorations'
+require 'decorum/decorator'
+require 'decorum/decorated_state'
+require 'decorum/chain_stop'
+require 'decorum/bare_particular'

data/lib/decorum/bare_particular.rb

@@ -0,0 +1,5 @@
+module Decorum
+  class BareParticular < Decorum::SuperHash
+    include Decorum::Decorations
+  end
+end

data/lib/decorum/chain_stop.rb

@@ -0,0 +1,7 @@
+module Decorum
+  class ChainStop
+    def method_missing(*args, &block)
+      throw :chain_stop, self
+    end
+  end
+end

data/lib/decorum/decorated_state.rb

@@ -0,0 +1,29 @@
+module Decorum
+  class DecoratedState 
+    def initialize(options={})
+      @shared_state = Decorum::SuperHash.new(options)
+    end
+
+    # this is one of two areas---the other being
+    # loading/unloading of decorators---where i
+    # suspect it isn't threadsafe now, but could
+    # pretty easily be made to be, e.g., in the 
+    # writer forwarder below:
+    #
+    #   lock = Monitor.new
+    #   lock.synchronize do
+    #     @state.send(message, *args)
+    #   end
+    # 
+    # more on this some other time.
+    def method_missing(message, *args)
+      if message =~ /=$/
+        # writer, in case we want to do something different here
+        @shared_state.send(message, *args)
+      else
+        # reader
+        @shared_state.send(message, *args)
+      end
+    end
+  end
+end

data/lib/decorum/decorations.rb

@@ -0,0 +1,101 @@
+module Decorum
+  module Decorations
+    def decorate(klass, options={})
+      extend Decorum::Decorations::Intercept
+      decorator = add_to_decorator_chain(klass, options)
+      yield decorator if block_given?
+      self
+    end
+
+    def undecorate(target)
+      remove_from_decorator_chain(target)
+      self
+    end
+
+    def decorators
+      if @_decorators
+        return @_decorators
+      elsif !@_decorator_chain
+        return []
+      end
+
+      decorator = @_decorator_chain
+      @_decorators = []
+      until decorator.is_a?(Decorum::ChainStop) 
+        @_decorators << decorator
+        decorator = decorator.next_link
+      end
+      @_decorators
+    end
+
+    def decorated_state(klass=nil)
+      @_decorated_state ||= {}
+
+      if klass
+        @_decorated_state[klass]
+      else
+        @_decorated_state
+      end
+    end
+ 
+    module Decorum::Decorations::Intercept
+      def method_missing(message, *args, &block)
+        response = catch :chain_stop do
+          @_decorator_chain.send(message, *args, &block)
+        end
+        response.is_a?(Decorum::ChainStop) ? super : response
+      end
+      
+      def respond_to_missing?(message, include_private = false)
+        decorators.each { |d| return true if d.respond_to?(message) }
+        super
+      end
+    end
+
+    protected
+
+    def add_to_decorator_chain(klass, options)
+      unless klass.ancestors.include?(Decorum::Decorator)
+        raise RuntimeError.new("decorator chain needs a Decorator")
+      end
+
+      if options[:decorator_handle]
+        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")
+        end
+      end
+
+      unless decorated_state(klass)
+        @_decorated_state[klass] = Decorum::DecoratedState.new
+      end
+
+      base = @_decorator_chain || Decorum::ChainStop.new
+      @_decorator_chain = klass.new(base, self, options)
+      decorators!
+      @_decorator_chain
+    end
+
+    def remove_from_decorator_chain(decorator)
+      return nil unless decorators.include?(decorator) 
+
+      if decorator == @_decorator_chain
+        @_decorator_chain = decorator.next_link
+      else
+        previous_decorator = decorators[decorators.index(decorator) - 1]
+        previous_decorator.next_link = decorator.next_link
+      end
+      
+      unless decorators!.map { |d| d.class }.include?(decorator.class)
+        @_decorated_state[decorator.class] = nil
+      end
+      decorators
+    end
+
+    def decorators!
+      @_decorators = nil
+      decorators
+    end
+  end
+end

data/lib/decorum/decorator.rb

@@ -0,0 +1,85 @@
+module Decorum
+  class Decorator
+    attr_accessor :next_link
+    attr_reader :root, :decorator_handle
+    alias_method :object, :root
+
+    def initialize(next_link, root, options)
+      @passed_options = options
+      @next_link = next_link
+      @root = root
+      @decorator_handle = options[:decorator_handle]
+
+      defaults = self.class.get_default_attributes
+      attribute_options = defaults ? defaults.merge(options) : options
+
+      attribute_options.each do |key, value|
+        setter = :"#{key}="
+        if respond_to?(setter)
+          send setter, value
+        end
+      end
+    end
+
+    # a superhash of shared state between Decorators
+    # of the same class
+    def decorated_state
+      root.decorated_state(self.class)
+    end
+
+    # Decorators that want stackable or cumulative 
+    # behavior can do so with tail recursion. Wrap
+    # the tail call in #decorated_tail to catch the
+    # end of the chain and return the accumulator
+    def decorated_tail(current_value=nil, &block)
+      response = catch :chain_stop do
+        yield
+      end
+      response.is_a?(Decorum::ChainStop) ? current_value : response
+    end
+
+    # delegate to next_link
+    # note that we are not faking #respond_to? because
+    # we want that to reflect what the decorator can
+    # respond to locally
+    def method_missing(*args, &block)
+      @next_link.send(*args, &block)
+    end
+
+    # class methods
+    class << self
+      # allow Decorator classes to share state among
+      # their instances
+      def share(*args)
+        args.each do |getter|
+          getter = getter.to_sym
+          define_method(getter) { self.decorated_state.send(getter) }
+
+          boolean = :"#{getter}?"
+          define_method(boolean) { self.decorated_state.send(getter) ? true : false }
+
+          setter = :"#{getter}="
+          define_method(setter) { |value| self.decorated_state.send(setter, value) }
+          
+          resetter = :"reset_#{getter}"
+          define_method(resetter) { self.decorated_state.send(setter, nil) }
+        end
+      end
+      
+      # hint as to how one might use these attributes
+      alias_method :accumulator, :share
+
+      # allow Decorator classes to provide attribute defaults (not shared)
+      def default_attributes(attrs)
+        @default_attributes = attrs
+        attrs.keys.each do |attr|
+          attr_accessor attr.to_sym
+        end
+      end
+
+      def get_default_attributes
+        @default_attributes || {}
+      end
+    end
+  end
+end

data/lib/decorum/version.rb

@@ -0,0 +1,3 @@
+module Decorum
+  VERSION = "0.0.1"
+end

data/spec/integration/coffee_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "when Bob is ordering a cup of coffee" do
+  let(:coffee) { Decorum::Examples::Coffee.new }
+
+  before(:each) do
+    coffee.decorate(Decorum::Examples::MilkDecorator, animal: "cow", milk_type: "2 percent")
+    coffee.decorate(Decorum::Examples::MilkDecorator, animal: "cow", milk_type: "2 percent")
+    coffee.decorate(Decorum::Examples::SugarDecorator)
+    coffee.add_milk
+    coffee.add_sugar
+  end
+  
+  it 'adds up to two milks' do
+    expect(coffee.milk_level).to be(2)
+  end
+
+  it 'has a sugar too' do
+    expect(coffee.sugar_level).to be(1)
+  end
+
+  context "things get interesting" do
+    before(:each) do 
+      ["bear", "man", "pig"].each do |critter|
+        coffee.decorate(Decorum::Examples::MilkDecorator, animal: critter)
+      end
+      coffee.add_milk 
+    end
+    
+    it 'gets another squirt from those original two cow milks' do
+      # just so we're clear on how this works---you have to clear
+      # the shared state yourself
+      expect(coffee.milk_level).to be(7)
+    end
+
+    it 'details Bob\'s dairy proclivities' do
+      expected_animals = ["pig", "man", "bear", "cow", "cow"]
+      expect(coffee.all_animals).to eq(expected_animals)
+    end
+  end
+end

data/spec/integration/fibonacci_spec.rb

@@ -0,0 +1,20 @@
+'require spec_helper'
+
+describe 'a Fibonacci sequence implemented in Decorators' do
+  let(:fibber) { Decorum::BareParticular.new }
+
+  before(:each) do
+    100.times do
+      fibber.decorate(Decorum::Examples::FibonacciDecorator)
+    end
+  end
+
+  it 'returns the 100th term' do 
+    expect(fibber.fib).to eq(927372692193078999176)
+  end
+
+  it 'stores the sequence' do
+    fibber.fib
+    expect(fibber.sequence.length).to eq(100)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require './lib/decorum.rb'
+
+Dir.glob("./spec/support/**/*.rb").each { |path| require path }
+Dir.glob("./examples/**/*.rb").each { |path| require path }

data/spec/support/decorated_state/shared_state_stub.rb

@@ -0,0 +1,15 @@
+module Decorum
+  module Spec
+    module DecoratedState
+      class SharedStateStub
+        def marker=(*args)
+          "assigned"
+        end
+
+        def marker
+          "retrieved"
+        end
+      end
+    end
+  end
+end

data/spec/support/decorations/decorated_object_stub.rb

@@ -0,0 +1,17 @@
+module Decorum
+  module Spec
+    module Decorations
+      class DecoratedObjectStub
+        include Decorum::Decorations
+        
+        def respect_previously_defined_methods?
+          true
+        end
+
+        def undecorated_method
+          true
+        end
+      end
+    end
+  end
+end

data/spec/support/decorations/first_decorator.rb

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

data/spec/support/decorations/second_decorator.rb

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