decorum 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7bfa93fae71415540de7bd2671d54885520c7c02
-  data.tar.gz: 3bfbf59a7418f85ab8c8127abf392b4ca05b1a3b
+  metadata.gz: 862e4435ac09860217f17edc406d6779a9f0414d
+  data.tar.gz: 8cbd6050375b8f40110cb5feaf667fee7280977b
 SHA512:
-  metadata.gz: 0ab83066bd10977de6e9490d94f0fe8f7c68300d5b67a200a239b15b3d1d5c7072f6b6767566ca2109ebd295ac96a59ff6833d86b67edfbb85ee2945e367c08a
-  data.tar.gz: 8f269196ea075f3fbe8fdf780f0c21441de56a65be5d18e9520bf0082b18a4dbed6df5b80d8e28a1ef3307942ce39933be8384f09f00c0d2b47f49a2900816a5
+  metadata.gz: 0ff3a972d777a846831dda2949a69f617372fb0fb896b7594e925b58e4f3a6172e95c68ee85e445f1491d55f68ae7a9b6e7ba8b595aaac662053b8677276d7b2
+  data.tar.gz: bd13f3a374b2fe2b36baed5e33bd03051e945e843438e72ccb747fc6759d205edf9925770c69ad1a6578ac08050daf8d13198ce58f3e7cd0513eca9f2f07a73f

data/.gitignore

@@ -1,3 +1,4 @@
+.*.swp
 *.gem
 *.rbc
 .bundle

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+# 0.5.0 / 2016-04-03
+* [FEATURE] public methods in Decorations (#decorate, #undecorate, etc.) may now be aliased
+
 # 0.4.1 / 2015-04-24
 * [BUGFIX] updated test suite for new rspec T/F comparison style
 

data/README.md

@@ -25,11 +25,17 @@ end
 bp = BirthdayParty.new
 bp.respond_to?(:shoot_confetti) # ==> false
 bp.is_decorated? # ==> false
+# but wait!
 bp.decorate(Confetti)
+# and now...
+bp.respond_to?(:shoot_confetti) # ==> true
 bp.is_decorated? # ==> true
 bp.shoot_confetti # ==> "boom, yay"
 ```
 
+## New in 0.5.0
+- The (public) methods in Decorum::Decorations (decorate, undecorate, etc.) may now be aliased. If you were having weird bugs beacuse Decorum was clobbering some existing method named `#decorate`, this is the version for you. More below.
+
 ## New in 0.4.0
 - Decorators and their attributes may now be specified in class definitions, and loaded with `#load_decorators_from_class`
 - `#is_decorated?`
@@ -245,9 +251,10 @@ See the source for more details.
 
 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 way is probably including 
+Note: this alone doesn't change the object's method lookup. It just makes
+`#decorate` and friends available on the object. (Note: As of 0.5.0 this
+isn't strictly true. See [Aliasing Decorum Methods](#aliasing-decorum-methods) below.) The behavior is only changed when
+`#decorate` is called. The easiest way is probably including 
 Decorum::Decorations at whatever point(s) of the class hierarchy you
 feel appropriate.
 
@@ -270,6 +277,7 @@ end
 r = Royalty.find_by_palace_name(:bob)
 r.respond_to? :styled_name # ==> false
 r.decorate StyledNameDecorator
+r.respond_to? :styled_name # ==> true
 r.styled_name # ==> "His Grace Most Potent Baron Sir Percy Arnold Robert \"Bob\" Gorpthwaite, Esq."
 ```
 
@@ -317,7 +325,7 @@ definition:
 class Coffee
   include Decorum::Decorations
   # two bovine dairy no sugar by default, please:
-  decorators Milk, { animal: "cow" }, Milk, { animal: "cow" }
+  decorum Milk, { animal: "cow" }, Milk, { animal: "cow" }
   ...
 end
 
@@ -327,6 +335,12 @@ c.add_milk
 c.milk_level # ==> 2
 ```
 
+(This class method was called `decorators` in versions prior to 0.5.0,
+but in the interest of avoiding naming conflicts, it's been changed to 
+`decorum`. If however you're using the standard [method aliases](#aliasing-decorum-methods),
+it will install an alias for `decorators`, allowing your existing stuff to 
+keep working without changes.)
+
 Note that this usage does _not_ automatically include decorators on new
 objects. That would require invasive procedures on your object initialization.
 Instead, Decorum provides `#load_decorators_from_class`, which you can call 
@@ -528,6 +542,46 @@ x.method_in_question # <== "overridden"
 If you declare `immediate` with no arguments, the decorators entire public interface
 is used. 
 
+### Aliasing Decorum methods
+
+Including/extending Decorum::Decorations makes a number of public methods (e.g., `#decorate`)
+available on an object, which can be a problem if methods under those names
+already exist. As of 0.5.0, these methods are actually implemented with "internalized"
+names, (e.g., `#_decorum_decorate`) and aliased after the fact. Decorum is loaded by requiring 
+two files: 
+
+```ruby
+# lib/decorum.rb
+require_relative 'decorum/noaliases'
+require_relative 'decorum/aliases'
+```
+
+The `noaliases` file loads up everything except aliasing; after requiring this file,
+public methods in Decorum::Decorations are available by their internal names. Aliases
+are then loaded for each of the public methods, either as specified in upcased environment variables
+(e.g., `_DECORUM_DECORATE="my_decorate_alias"`) or failing that, the default values
+in `aliases`. Here are the public methods and their defaults:
+
+```ruby
+# from lib/decorum/aliases.rb
+    DEFAULT_ALIASES = { _decorum_decorate: "decorate",
+      _decorum_undecorate: "undecorate",
+      _decorum_is_decorated?: "is_decorated?",
+      _decorum_decorators: "decorators",
+      _decorum_decorated_state: "decorated_state",
+      _decorum_load_decorators_from_class: "load_decorators_from_class",
+      _decorum_raw_decorators: nil,
+      _decorum_raw_decorators!: nil,
+      _decorum_namespaces: nil }
+```
+
+The `.decorum` method made available to modules when they include Decorum::Decorations is also
+aliased here as either the value of `_DECORUM_CLASS_DECORATORS` or just `.decorators`.
+
+If you need something else, (e.g., more finely grained aliases) you can just `require decorum/noaliases`,
+and all of Decorum's aliasing will be skipped. You can then implement your own scheme however you like. 
+
+
 ### Decorators All the Way Down
 
 Decorum includes a class called Decorum::BareParticular, which descends from
@@ -539,8 +593,7 @@ return nil by default.
 
 ## To-do
 A few things I can imagine showing up soon:
-- An easy way to alias the main methods (#decorate, #undecorate), as you might
-  want those names for something else.
+- See open issues
 - Thread safety: probably not an issue if you're retooling your Rails helpers,
   but consider a case like this:
 

data/lib/decorum.rb

@@ -1,39 +1,3 @@
-# decorum.rb
-require 'ostruct'
-
-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
-
-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'
+# lib/decorum.rb
+require_relative 'decorum/noaliases'
+require_relative 'decorum/aliases'

data/lib/decorum/aliases.rb

@@ -0,0 +1,50 @@
+# Here we alias public methods defined by Decorum::Decorations, 
+# because these will appear in other people's classes and should
+# therefore not cause conflcts. Public methods:
+#   _decorum_decorate
+#   _decorum_undecorate
+#   _decorum_is_decorated?
+#   _decorum_decorators
+#   _decorum_decorated_state
+#   _decorum_load_decorators_from_class
+#
+# and these three more "internal" methods, no default aliases:
+#   _decorum_raw_decorators
+#   _decorum_raw_decorators!
+#   _decorum_namespaces
+#
+# you can also specify a capitalized method name in env for 
+# something other than default, e.g., 
+#
+#   _DECORUM_DECORATE='my_funky_decorate_alias' 
+#
+# otherwise it will fall back on defaults; to bypass this 
+# entirely load decorum/noaliases
+
+module Decorum
+  module Decorations
+    module ClassMethods
+      class_method_alias = ENV['_DECORUM_CLASS_DECORATORS'] || "decorators"
+      alias_method class_method_alias, :decorum
+    end
+
+    DEFAULT_ALIASES = { _decorum_decorate: "decorate",
+      _decorum_undecorate: "undecorate",
+      _decorum_is_decorated?: "is_decorated?",
+      _decorum_decorators: "decorators",
+      _decorum_decorated_state: "decorated_state",
+      _decorum_load_decorators_from_class: "load_decorators_from_class",
+      _decorum_raw_decorators: nil,
+      _decorum_raw_decorators!: nil,
+      _decorum_namespaces: nil }
+
+
+    DEFAULT_ALIASES.each do |k, v|
+      aliased_name = ENV["#{k.upcase}"] || v
+      if aliased_name
+        alias_method aliased_name, k
+      end
+    end
+  end
+end
+        

data/lib/decorum/callable_decorator.rb

@@ -3,6 +3,11 @@ module Decorum
     def initialize(decorator)
       @_decorator = decorator
     end
+
+    # tortuously named to avoid conflict and discourage use
+    def _actual_decorator
+      @_decorator
+    end
     
     def method_missing(message, *args, &block)
       response = catch :chain_stop do

data/lib/decorum/decorations.rb

@@ -1,8 +1,8 @@
 module Decorum
   module Decorations
-    def self.included(modyool)
       # class method to declare default decorators
-      def modyool.decorators(*args)
+    module ClassMethods
+      def decorum(*args)
         # set first-listed priority
         if args[0] == :reverse
           return @_decorum_stack_reverse = true
@@ -27,11 +27,15 @@ module Decorum
         end
       end 
     end
+
+    # load the class method(s)
+    def self.included(modyool)
+      modyool.extend Decorum::Decorations::ClassMethods
+    end
   
     # public instance methods
 
-
-    def decorate(klass, options={})
+    def _decorum_decorate(klass, options={})
       if namespace_method = options.delete(:namespace)
         decorator = nil
         namespace = nil
@@ -40,128 +44,131 @@ module Decorum
           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 }
+          namespace._decorum_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)
+          namespace._decorum_decorate(klass, options) { |d| decorator = d }
+          instance_variable_set(:"@_decorum_ns_#{namespace_method}", namespace)
           m = Module.new do
             define_method(namespace_method) do
-              instance_variable_get(:"@_decorum_#{namespace_method}")
+              instance_variable_get(:"@_decorum_ns_#{namespace_method}")
             end
           end
           extend m
-          _decorator_namespaces << namespace_method
+          _decorum_namespaces << namespace_method
         end
-        yield CallableDecorator.new(decorator) if block_given?
+        yield Decorum::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 = _add_to_decorum_chain(klass, options)
+        yield Decorum::CallableDecorator.new(decorator) if block_given?
         decorator.post_decorate
       end 
       self
     end
 
-    def undecorate(target)
-      remove_from_decorator_chain(target)
+    def _decorum_undecorate(target)
+      _remove_from_decorum_chain(target)
       self
     end
     
-    def is_decorated?
-      ![ decorators, _decorator_namespaces.map { |ns| send(ns).decorators } ].flatten.empty?
+    def _decorum_is_decorated?
+      ![ _decorum_decorators, _decorum_namespaces.map { |ns| send(ns)._decorum_decorators } ].flatten.empty?
     end
    
     # returns callable decorators---use this
-    def decorators
-      _decorators.map { |d| CallableDecorator.new(d) }
+    def _decorum_decorators
+      _decorum_raw_decorators.map { |d| Decorum::CallableDecorator.new(d) }
     end
 
     # leaving it to you to, say, call this from #initialize
-    def load_decorators_from_class
-      self.class.decorators.each { |decorator_class, options| decorate(decorator_class, options) }
+    def _decorum_load_decorators_from_class
+      self.class.decorators.each { |decorator_class, options| _decorum_decorate(decorator_class, options) }
       self
     end
 
     # returns raw decorators---don't use this unless
     # you know what you're doing
-    def _decorators
-      if @_decorators
-        return @_decorators
-      elsif !@_decorator_chain
+    def _decorum_raw_decorators
+      # the array of raw decorators is memoized; set
+      # @_decorum_raw_decorators to nil/false to rebuild
+      if @_decorum_raw_decorators
+        return @_decorum_raw_decorators
+      elsif !@_decorum_chain_reference
         return []
       end
 
-      decorator = @_decorator_chain
-      @_decorators = []
+      # rebuild the array representation of decorators
+      decorator = @_decorum_chain_reference
+      @_decorum_raw_decorators = []
       until decorator.is_a?(Decorum::ChainStop) 
-        @_decorators << decorator
+        @_decorum_raw_decorators << decorator
         decorator = decorator.next_link
       end
-      @_decorators
+      @_decorum_raw_decorators
     end
 
     # reset the decorator collection
-    def _decorators!
-      @_decorators = nil
-      _decorators
+    def _decorum_raw_decorators!
+      @_decorum_raw_decorators = nil
+      _decorum_raw_decorators
     end
 
-    def decorated_state(klass=nil)
-      @_decorated_state ||= {}
+    def _decorum_decorated_state(klass=nil)
+      @_decorum_decorated_state ||= {}
 
       if klass
-        @_decorated_state[klass]
+        @_decorum_decorated_state[klass]
       else
-        @_decorated_state
+        @_decorum_decorated_state
       end
     end
 
-    def _decorator_namespaces
-      @_decorator_namespaces ||= []
+    def _decorum_namespaces
+      @_decorum_namespaces ||= []
     end
  
     module Decorum::Decorations::Intercept
       def method_missing(message, *args, &block)
         response = catch :chain_stop do
-          @_decorator_chain.send(message, *args, &block)
+          @_decorum_chain_reference.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) }
+        _decorum_raw_decorators.each { |d| return true if d.respond_to?(message) }
         super
       end
     end
 
     private
 
-    def add_to_decorator_chain(klass, options)
+    def _add_to_decorum_chain(klass, options)
       unless klass.ancestors.include?(Decorum::Decorator)
         raise TypeError, "decorator chain needs a Decorator"
       end
 
       if options[:decorator_handle]
-        current_names = _decorators.map { |d| d.decorator_handle.to_sym }.compact
+        current_names = _decorum_raw_decorators.map { |d| d.decorator_handle.to_sym }.compact
         if current_names.include?(options[:decorator_handle].to_sym)
           raise RuntimeError, "decorator names must be unique over an object"
         end
       end
 
-      unless decorated_state(klass)
-        @_decorated_state[klass] = Decorum::DecoratedState.new
+      unless _decorum_decorated_state(klass)
+        @_decorum_decorated_state[klass] = Decorum::DecoratedState.new
       end
 
-      base = @_decorator_chain || Decorum::ChainStop.new
-      @_decorator_chain = klass.new(base, self, options)
+      base = @_decorum_chain_reference || Decorum::ChainStop.new
+      @_decorum_chain_reference = klass.new(base, self, options)
 
       if klass.immediate_methods
         immediate = Module.new do
           klass.immediate_methods.each do |method_name|
             define_method(method_name) do |*args, &block|
               response = catch :chain_stop do
-                @_decorator_chain.send(__method__, *args, &block)
+                @_decorum_chain_reference.send(__method__, *args, &block)
               end
               response.is_a?(Decorum::ChainStop) ? super(*args, &block) : response
             end
@@ -169,30 +176,30 @@ module Decorum
         end
         extend immediate
       end
-      _decorators!
-      @_decorator_chain
+      _decorum_raw_decorators!
+      @_decorum_chain_reference
     end
 
-    def remove_from_decorator_chain(decorator)
-      if decorator.is_a?(CallableDecorator) 
-        decorator = decorator.instance_variable_get(:@_decorator)
+    def _remove_from_decorum_chain(decorator)
+      if decorator.is_a?(Decorum::CallableDecorator) 
+        decorator = decorator._actual_decorator
       end
 
-      unless (decorator.is_a?(Decorum::Decorator) && _decorators.include?(decorator))
+      unless (decorator.is_a?(Decorum::Decorator) && _decorum_raw_decorators.include?(decorator))
         return nil
       end
 
-      if decorator == @_decorator_chain
-        @_decorator_chain = decorator.next_link
+      if decorator == @_decorum_chain_reference
+        @_decorum_chain_reference = decorator.next_link
       else
-        previous_decorator = _decorators[_decorators.index(decorator) - 1]
+        previous_decorator = _decorum_raw_decorators[_decorum_raw_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
+      unless _decorum_raw_decorators!.map { |d| d.class }.include?(decorator.class)
+        @_decorum_decorated_state[decorator.class] = nil
       end
-      _decorators
+      _decorum_raw_decorators
     end
   end
 end

data/lib/decorum/decorator.rb

@@ -5,9 +5,9 @@ module Decorum
     alias_method :object, :root
 
     def initialize(next_link, root, options)
-      @passed_options = options
-      @next_link = next_link
-      @root = root
+      @passed_options   = options
+      @next_link        = next_link
+      @root             = root
       @decorator_handle = options[:decorator_handle]
 
       defaults = self.class.get_default_attributes
@@ -29,7 +29,7 @@ module Decorum
     # a superhash of shared state between Decorators
     # of the same class
     def decorated_state
-      root.decorated_state(self.class)
+      root._decorum_decorated_state(self.class)
     end
 
     # Decorators that want stackable or cumulative 

data/lib/decorum/noaliases.rb

@@ -0,0 +1,42 @@
+# decorum/noaliases - this does all of the core setup, everything
+# except aliasing public methods in Decorum::Decorations. provided
+# separately so users can bypass the alias process entirely if desired.
+
+require 'ostruct'
+
+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
+
+module Decorum
+end
+
+Decorum::SuperHash    = superhash_class
+Decorum::SharedState  = shared_state_class
+
+require_relative 'version'
+require_relative 'decorations'
+require_relative 'decorator'
+require_relative 'decorated_state'
+require_relative 'chain_stop'
+require_relative 'bare_particular'
+require_relative 'callable_decorator'
+require_relative 'decorator_namespace'

data/lib/decorum/version.rb

@@ -1,3 +1,3 @@
 module Decorum
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/spec/integration/coffee_spec.rb

@@ -4,9 +4,9 @@ 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._decorum_decorate(Decorum::Examples::MilkDecorator, animal: "cow", milk_type: "2 percent")
+    coffee._decorum_decorate(Decorum::Examples::MilkDecorator, animal: "cow", milk_type: "2 percent")
+    coffee._decorum_decorate(Decorum::Examples::SugarDecorator)
     coffee.add_milk
     coffee.add_sugar
   end
@@ -22,7 +22,7 @@ describe "when Bob is ordering a cup of coffee" do
   context "things get interesting" do
     before(:each) do 
       ["bear", "man", "pig"].each do |critter|
-        coffee.decorate(Decorum::Examples::MilkDecorator, animal: critter)
+        coffee._decorum_decorate(Decorum::Examples::MilkDecorator, animal: critter)
       end
       coffee.add_milk 
     end

data/spec/integration/fibonacci_spec.rb

@@ -5,7 +5,7 @@ describe 'a Fibonacci sequence implemented in Decorators' do
 
   before(:each) do
     100.times do
-      fibber.decorate(Decorum::Examples::FibonacciDecorator)
+      fibber._decorum_decorate(Decorum::Examples::FibonacciDecorator)
     end
   end
 

data/spec/integration/immediate_methods_spec.rb

@@ -8,18 +8,18 @@ describe "When overriding original methods with .immediate" do
   end
 
   it "overrides original methods" do
-    base_object.decorate(Decorum::Examples::StrongWilledDecorator)
+    base_object._decorum_decorate(Decorum::Examples::StrongWilledDecorator)
     expect(base_object.method_in_question).to eq("overridden")
   end
 
   it "reverts to original method when decorator is unloaded" do
-    base_object.decorate(Decorum::Examples::StrongWilledDecorator)
-    base_object.undecorate(base_object.decorators.first)
+    base_object._decorum_decorate(Decorum::Examples::StrongWilledDecorator)
+    base_object._decorum_undecorate(base_object._decorum_decorators.first)
     expect(base_object.method_in_question).to eq("original")
   end
 
   it "stops chain on vanished method" do
-    base_object.decorate(Decorum::Examples::StrongWilledDecorator)
+    base_object._decorum_decorate(Decorum::Examples::StrongWilledDecorator)
     # raise on violated assumptions rather than have multiple conditions in the same test?
     resp =  base_object.second_immediate_method 
     unless resp == "method dos"
@@ -27,17 +27,17 @@ describe "When overriding original methods with .immediate" do
       raise bail_message
     end
 
-    base_object.undecorate(base_object.decorators.first)
+    base_object._decorum_undecorate(base_object._decorum_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) }
+    4.times { base_object._decorum_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) }
+    4.times { base_object._decorum_decorate(Decorum::Examples::ImmediateDecorator, namespace: :foo) }
     expect(base_object.foo.increment_immediately_shared).to eq(4)
   end
 end

data/spec/support/decorator/decorated_object_stub.rb

@@ -8,8 +8,8 @@ module Decorum
           true
         end
         
-        def decorated_state(*args)
-          @decorated_state ||= Decorum::Spec::Decorator::DecoratedStateStub.new
+        def _decorum_decorated_state(*args)
+          @_decorum_decorated_state ||= Decorum::Spec::Decorator::DecoratedStateStub.new
         end
       end
     end

data/spec/unit/bare_particular_spec.rb

@@ -8,6 +8,6 @@ describe Decorum::BareParticular do
   end
 
   it 'black holes undefined methods' do
-    expect(bp.nonexistent_method).to be_nil
+    expect(bp.this_method_absolutely_doesnt_exist).to be_nil
   end
 end

data/spec/unit/callable_decorator_spec.rb

@@ -4,7 +4,7 @@ describe Decorum::CallableDecorator do
   let(:decorator) do 
     c = Decorum::Examples::Coffee.new
     decorator = nil
-    c.decorate(Decorum::Examples::MilkDecorator) { |d| decorator = d }
+    c._decorum_decorate(Decorum::Examples::MilkDecorator) { |d| decorator = d }
     decorator
   end
 

data/spec/unit/chain_stop_spec.rb

@@ -5,7 +5,7 @@ describe Decorum::ChainStop do
 
   it 'throws self via :chain_stop on undefined method' do
     response = catch :chain_stop do 
-      chainstop.nonexistent_method
+      chainstop.this_method_absolutely_doesnt_exist
     end
     expect(response).to be_equal(chainstop)
   end

data/spec/unit/decorations_spec.rb

@@ -6,39 +6,39 @@ describe Decorum::Decorations do
   let(:deco_class_2) { Decorum::Spec::Decorations::SecondDecorator }
   let(:deco_class_3) { Decorum::Spec::Decorations::ThirdDecorator }
 
-  context 'loading decorators from class defaults' do
+  context 'loading decorators from class defaults via .decorum' do
     let(:klass) do 
       Class.new do
         include Decorum::Decorations
-        decorators Decorum::Spec::Decorations::ClassSpecifiedDecoratorOne, { passed_option: "one" },
+        decorum Decorum::Spec::Decorations::ClassSpecifiedDecoratorOne, { passed_option: "one" },
           Decorum::Spec::Decorations::ClassSpecifiedDecoratorTwo, { passed_option: "two" }
       end
     end
 
-    describe '.decorators' do
+    describe '.decorum' do
       it 'stores decorators in own state correctly' do
-        expect(klass.decorators.map { |d| d[0].ancestors.include?(Decorum::Decorator) }.inject(:&)).to be true
+        expect(klass.decorum.map { |d| d[0].ancestors.include?(Decorum::Decorator) }.inject(:&)).to be true
       end
 
       # the instance method #load_decorators_from_class will insert them in the order given:
       
       it 'normally gives first priority to last listed' do
-        expect(klass.decorators.map { |d| d[1] } == [{ passed_option: "one" }, { passed_option: "two" }]).to be true
+        expect(klass.decorum.map { |d| d[1] } == [{ passed_option: "one" }, { passed_option: "two" }]).to be true
       end
 
       it 'reverses order for first-specfied priority' do
         klass.decorators :reverse
-        expect(klass.decorators.map { |d| d[1] } == [{ passed_option: "two" }, { passed_option: "one" }]).to be true
+        expect(klass.decorum.map { |d| d[1] } == [{ passed_option: "two" }, { passed_option: "one" }]).to be true
       end
 
       it 'rejects malformed options' do
-        expect { klass.decorators(Decorum::Spec::Decorations::FirstDecorator, "invalid decorator argument") }.to raise_error
+        expect { klass.decorum(Decorum::Spec::Decorations::FirstDecorator, "invalid decorator argument") }.to raise_error
       end
 
       # this probably belongs with other instance methods below, but we've got the 
       # support objects built for it here...
       describe '#decorators' do 
-        let(:obj) { klass.new.load_decorators_from_class }
+        let(:obj) { klass.new._decorum_load_decorators_from_class }
         it 'returns self' do
           # sort of
           expect(obj.is_a?(klass)).to be true
@@ -69,71 +69,71 @@ describe Decorum::Decorations do
       expect(decorated.undecorated_method).to be true
     end
 
-    describe '#is_decorated?' do
+    describe '#_decorum_is_decorated?' do
       it 'is false' do
-        expect(decorated.is_decorated?).to be false
+        expect(decorated._decorum_is_decorated?).to be false
       end
     end
 
-    describe '#decorated_state' do
+    describe '#_decorum_decorated_state' do
       it 'returns a hash' do
-        blank_state = decorated.decorated_state
+        blank_state = decorated._decorum_decorated_state
         expect(blank_state.is_a?(Hash)).to be true
       end
 
       it 'returns an empty hash' do
-        blank_state = decorated.decorated_state
+        blank_state = decorated._decorum_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
+        expect(decorated._decorum_decorated_state(:not_gonna_work)).to be_nil
       end
     end
     
-    describe 'undecorate' do
+    describe '#_decorum_undecorate' do
       it 'returns self on symbol' do
-        expect(decorated.undecorate(:symbol_arg)).to be_equal(decorated)
+        expect(decorated._decorum_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)
+        expect(decorated._decorum_undecorate(deco_class_1)).to be_equal(decorated)
       end
     end
   end
 
   context 'decorated' do
-    describe '#decorate' do
+    describe '#_decorum_decorate' do
       it 'returns self on decoration' do
         real_decorated = decorated
-        expect(decorated.decorate(deco_class_1)).to be_equal(real_decorated)
+        expect(decorated._decorum_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")
+        expect(decorated._decorum_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.instance_variable_get(:@_decorator)).to be(actual_decorator)
+        decorated._decorum_decorate(deco_class_1) { |dec| decorator = dec }
+        actual_decorator = decorated.instance_variable_get(:@_decorum_chain_reference)
+        expect(decorator._actual_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)
+          decorated._decorum_decorate(deco_class_1, decorator_options)
         end
 
-        describe '#is_decorated?' do
+        describe '#_decorum_is_decorated?' do
           it 'returns true' do
-            expect(decorated.is_decorated?).to be true
+            expect(decorated._decorum_is_decorated?).to be true
           end
           
           it 'returns false after unloading' do
-            decorated.undecorate(decorated.decorators.first)
-            expect(decorated.is_decorated?).to be false
+            decorated._decorum_undecorate(decorated._decorum_decorators.first)
+            expect(decorated._decorum_is_decorated?).to be false
           end
         end
             
@@ -142,7 +142,7 @@ describe Decorum::Decorations do
         end
 
         it 'sets internal state' do
-          internal_state = decorated.instance_variable_get(:@_decorator_chain)
+          internal_state = decorated.instance_variable_get(:@_decorum_chain_reference)
           expect(internal_state.is_a?(deco_class_1)).to be true
         end
 
@@ -155,7 +155,7 @@ describe Decorum::Decorations do
         end
 
         it 'raises NoMethodError on nonexistent method' do
-          expect { decorated.nonexistent_method }.to raise_error(NoMethodError)
+          expect { decorated.this_method_absolutely_doesnt_exist }.to raise_error(NoMethodError)
         end
         
         it 'is decorated by local attributes' do
@@ -167,14 +167,14 @@ describe Decorum::Decorations do
         end
 
         it 'creates decorated state for decorator class' do
-          expect(decorated.decorated_state(deco_class_1).shared_attribute).to eq('shared 1')
+          expect(decorated._decorum_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)
+              decorated._decorum_decorate(klass)
             end
           end
 
@@ -193,21 +193,21 @@ describe Decorum::Decorations do
 
       context 'failure' do
         it 'rejects classes that are not Decorators' do
-          expect { decorated.decorate(Class,{}) }.to raise_error(TypeError)
+          expect { decorated._decorum_decorate(Class, {}) }.to raise_error(TypeError)
         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}")
+            decorated._decorum_decorate(klass, decorator_handle: "deco-#{i + 1}")
           end
-          expect { decorated.decorate(deco_class_1, decorator_handle: "deco-2") }.to raise_error(RuntimeError)
+          expect { decorated._decorum_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) }
+      before(:each) { decorated._decorum_decorate(deco_class_1) }
 
       it 'returns true for decorated methods' do  
         expect(decorated.respond_to?(:first_decorator_method)).to be true
@@ -218,7 +218,7 @@ describe Decorum::Decorations do
       end
 
       it 'returns false for undefined method' do
-        expect(decorated.respond_to?(:nonexistent_method)).to be false
+        expect(decorated.respond_to?(:this_method_absolutely_doesnt_exist)).to be false
       end
     end
 
@@ -226,31 +226,31 @@ describe Decorum::Decorations do
       before(:each) do
         3.times do |x|
           klass = send(:"deco_class_#{x + 1}")
-          decorated.decorate(klass, decorator_handle: "deco-#{x + 1}")
+          decorated._decorum_decorate(klass, decorator_handle: "deco-#{x + 1}")
         end
       end
 
-      describe '#decorators' do
+      describe '#_decorum_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)
+          expect(decorated._decorum_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)
+          decorated._decorum_decorators[0].next_link = decorated._decorum_decorators[2]
+          expect(decorated._decorum_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)
+        it 'refreshes via #_decorum_raw_decorators!' do
+          decorated._decorum_raw_decorators[0].next_link = decorated._decorum_raw_decorators[2]
+          decorated.send(:_decorum_raw_decorators!)
+          expect(decorated._decorum_decorators.length).to be(2)
         end
       end
 
-      describe '#undecorate' do 
+      describe '#_decorum_undecorate' do 
         before(:each) do
-          @undec = decorated.decorators.detect { |d| d.decorator_handle == "deco-2" }
+          @undec = decorated._decorum_decorators.detect { |d| d.decorator_handle == "deco-2" }
           # just to make sure...
           unless @undec.is_a?(Decorum::CallableDecorator)
             raise "broken test---no such decorator deco-2; undec was #{@undec.inspect}"
@@ -258,23 +258,23 @@ describe Decorum::Decorations do
         end
 
         it 'undecorates' do
-          decorated.undecorate(@undec)
-          expect(decorated.decorators.length).to be(2)
+          decorated._decorum_undecorate(@undec)
+          expect(decorated._decorum_decorators.length).to be(2)
         end
 
         it 'undecorates the right one' do
-          decorated.undecorate(@undec)
+          decorated._decorum_undecorate(@undec)
           expected_map = ["deco-3", "deco-1"]
-          expect(decorated.decorators.map { |d| d.decorator_handle }).to eq(expected_map)
+          expect(decorated._decorum_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)
+          expect(decorated._decorum_undecorate(@undec)).to be_equal(real_decorated)
         end
         
         context 'once undecorated' do
-          before(:each) { decorated.undecorate(@undec) }
+          before(:each) { decorated._decorum_undecorate(@undec) }
 
           it 'no longer responds to removed decorated method' do
             expect(decorated.respond_to?(:second_decorator_method)).to be false
@@ -289,11 +289,11 @@ describe Decorum::Decorations do
           end
 
           it 'destroys shared state when last class member is gone' do
-            expect(decorated.decorated_state(deco_class_2)).to be_nil
+            expect(decorated._decorum_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)
+            expect(decorated._decorum_decorated_state(deco_class_1)).to be_a(Decorum::DecoratedState)
           end
         end 
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: decorum
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Erik Cameron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-24 00:00:00.000000000 Z
+date: 2016-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,6 +75,7 @@ files:
 - examples/sugar_decorator.rb
 - examples/weak_willed_class.rb
 - lib/decorum.rb
+- lib/decorum/aliases.rb
 - lib/decorum/bare_particular.rb
 - lib/decorum/callable_decorator.rb
 - lib/decorum/chain_stop.rb
@@ -82,6 +83,7 @@ files:
 - lib/decorum/decorations.rb
 - lib/decorum/decorator.rb
 - lib/decorum/decorator_namespace.rb
+- lib/decorum/noaliases.rb
 - lib/decorum/version.rb
 - spec/integration/coffee_spec.rb
 - spec/integration/fibonacci_spec.rb