activesupport-decorators 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ac0e53aa4f0f2a5552ebdffb9bc6f8862bfb583
-  data.tar.gz: 0bc4b6985d4c867c732345478627e3ed2c69be1f
+  metadata.gz: 68468583a43ef2fe9365a6d4f47f6e96a5cb2520
+  data.tar.gz: fa6523c3c0aafa1a4c5d669e415037a5fdd89bef
 SHA512:
-  metadata.gz: a7ea6a25f3474820c952786c12d9c04d6062ee8bc398b2b003170432561ef479bc82d32a3367f86640349c5d204da5ca4832078e4eeccad10163fe1129b3bb46
-  data.tar.gz: d68066a4e76725ffd03bfd4efa174f7fed47ebc686f006c9e458b551ef311a6d72bee37e8f039b492b942f87fdd612612d2df3154a4b8a8559bcd49d9a93c6a3
+  metadata.gz: fc7f2882249afc13d84c940f50e2d3fb7d721d5d489b217cedf7a5d85b3c091597838e7d785c667995e94e11fff3f5a9c64872352dbef8ae6130bb0915dac20a
+  data.tar.gz: f1705d7f814348c16b4bd62506fc1f304351d6c2ab87f3a88dfe2cc4c1e8d374ff12917a43e85f690b76dbbe7080b621133f8736b49a850702374b03d5502c75

data/README.md

@@ -4,11 +4,10 @@ ActiveSupport Decorators
 The decorator pattern is particularly useful when extending constants in rails engines or vice versa.  To implement
 the decorator pattern, you need to load the decorator after the original file has been loaded.  When you reference a
 class in a Rails application, ActiveSupport will only load the first file it finds that matches the class name.  This
-means that you will need to manually load the additional (decorator) file.  Usually you don't want to want to introduce
-hard dependencies such as require statements.  You also don't want to preload a bunch of classes in a Rails initializer.
-This is a tiny gem that provides you with a simple way to specify load file dependencies.
+means that you need to manually load the additional (decorator) file or eager load all of them on application startup.
+This is a tiny gem that provides you with a simple way to tell ActiveSupport to load your decorator files when needed.
 
-## Installation
+### Installation
 
 Add it to your Gemfile and run bundle install:
 
@@ -16,7 +15,7 @@ Add it to your Gemfile and run bundle install:
 gem 'activesupport-decorators', '~> 1.0'
 ```
 
-## Example 1 - Engine extends application class.
+#### Example 1 - Engine extends application class.
 
 Your main rails application defines a model called Pet (in app/models/pet.rb):
 
@@ -26,7 +25,8 @@ end
 ```
 
 Your rails engine adds the concept of pet owners to the application.  You extend the Pet model in the engine with
-the following model decorator (in my_engine/app/models/pet_decorator.rb).
+the following model decorator (in my_engine/app/models/pet_decorator.rb).  Note that you could use 'class Pet' instead
+of 'Pet.class_eval do'.
 
 ```Ruby
 Pet.class_eval do
@@ -49,7 +49,7 @@ module MyEngine
 end
 ```
 
-## Example 2 - Application extends engine class.
+#### Example 2 - Application extends engine class.
 
 Similar to the example above except the initializer is placed in the main application instead of the engine.  Create a
 file called config/initializers/set_decorator_dependencies.rb (or any other name) with content:
@@ -58,21 +58,21 @@ file called config/initializers/set_decorator_dependencies.rb (or any other name
 ActiveSupportDecorators.add("#{MyEngine::Rails::Engine.root}/app", "#{Rails.root}/app")
 ```
 
-## Example 3 - Engine extends another engine class.
+#### Example 3 - Engine extends another engine class.
 
 ```Ruby
 module MyEngine
   module Rails
     class Engine < ::Rails::Engine
       initializer :set_decorator_dependencies do |app|
-        ActiveSupportDecorators.add("#{AnotherEngine::Rails::Engine.root}/app", "#{Rails.root}/app")
+        ActiveSupportDecorators.add("#{AnotherEngine::Rails::Engine.root}/app", "#{MyEngine::Rails::Engine.root}/app")
       end
     end
   end
 end
 ```
 
-## Debugging
+### Debugging
 
 Need to know which decorator files are loaded?  Enable debug output:
 
@@ -80,32 +80,18 @@ Need to know which decorator files are loaded?  Enable debug output:
 ActiveSupportDecorators.debug = true
 ```
 
-## Decorator file pattern
-
-By default decorator files are matched with '_decorator' appended to the file name.  You can remove this suffix
-completely or use your own one.  Note the method signature of add:
-
-```Ruby
-ActiveSupportDecorators.add(path, decorator_path, file_pattern = '_decorator')
-```
-
-## Decorating decorators
-
-Nested decorators are supported.  Just set them to decorate a path where the dependant decorators are placed.
-
-## Comparison to other gems
-
-This is yet another decorator gem because it:
-* allows you to specify where and how you name decorators.
-* allows you to limit the paths you decorate.
-* other gems tend to eager load as seen [here]
-  (https://github.com/atd/rails_engine_decorators/blob/master/lib/rails_engine_decorators/engine/configuration.rb)
-  and [here](https://github.com/parndt/decorators/blob/master/lib/decorators/railtie.rb).
-* other gems assume you use 'MyClass.class_eval' to define decorators since it is how you trigger activesupport to load
-  the original file.  This gem allows you to use the normal 'class MyClass' which means you can define constants in
-  decorators.
-
-However if you do not want to specify which path's you allow to be decorated, you should use another gem.  Instead of
-single file look ups it will need to search your decorator directories for a matching file, which is not feasible
-especially in a context where any ruby file may be decorated.  The best solution for such a scenario would be to
-eager load the decorators like other gems do.
+### Comparison to other gems
+
+Other gems work by simply telling Rails to eager load all your decorators on application startup as seen [here]
+(https://github.com/atd/rails_engine_decorators/blob/master/lib/rails_engine_decorators/engine/configuration.rb) and
+[here](https://github.com/parndt/decorators/blob/master/lib/decorators/railtie.rb).  They expect your decorators to use
+'MyClass.class_eval do' to extend the original class as this is what triggers the original class to be loaded.
+Disadvantages of this approach include:
+* decorators may not expect other classes to be decorated already, it's a bad idea to depend on load order.
+* development mode is a bit slower since your decorator eager loading usually has a cascade effect on the application.
+  This is more noticeable when using JRuby as it will be a compile action instead of class load action.
+* using 'MyClass.class_eval do' instead of 'class MyClass' means you can not define constants.
+
+This gem works by hooking into ActiveSupport, which means that decorators are loaded as required instead of at
+application startup.  You can use 'class MyClass' and expect that other classes are already decorated, since when you
+reference other classes they will be decorated on the fly when ActiveSupport loads them.

data/lib/active_support_decorators/active_support_decorators.rb

@@ -1,18 +1,17 @@
-require 'active_support_decorators/graph'
-
 module ActiveSupportDecorators
-  Dependency = Struct.new(:path, :decorator_path, :file_pattern)
+  DECORATOR_PATTERN = '_decorator'
 
   def self.clear
     dependencies.clear
   end
 
   def self.dependencies
-    @dependencies ||= []
+    @dependencies ||= {}
   end
 
-  def self.add(path, decorator_path, file_pattern = '_decorator')
-    dependencies << Dependency.new(path, decorator_path, file_pattern)
+  def self.add(path, decorator_path)
+    dependencies[path] ||= []
+    dependencies[path] << decorator_path
   end
 
   def self.debug
@@ -26,34 +25,44 @@ module ActiveSupportDecorators
   private
   def self.load_path_order(file_name)
     # Do not process with .rb extension if provided.
-    sanitized_file_name = file_name.sub(/\.rb$/,'')
-
-    graph = Graph.new
-    graph.add(sanitized_file_name)
+    sanitized_file_name = file_name.sub(/\.rb$/, '')
+    decorated_file = nil
+    decorators = []
 
-    dependencies.each do |dep|
-      # If an attempt is made to load the original file, ensure the decorators are loaded afterwards.
-      if sanitized_file_name.starts_with?(dep.path)
-        relative_name = sanitized_file_name.sub(dep.path, '')
-        decorator_file = "#{dep.decorator_path}#{relative_name}#{dep.file_pattern}"
+    dependencies.each do |path, decorator_paths|
+      decorator_paths.each do |decorator_path|
+        # If an attempt is made to load the original file, ensure the decorators are loaded afterwards.
+        if sanitized_file_name.starts_with?(path)
+          relative_name = sanitized_file_name.sub(path, '')
+          candidate_file = "#{decorator_path}#{relative_name}#{DECORATOR_PATTERN}"
 
-        if File.file?(decorator_file + '.rb')
-          graph.add_with_edge(sanitized_file_name, decorator_file)
+          if File.file?(candidate_file + '.rb')
+            decorated_file = sanitized_file_name
+            decorators << candidate_file
+          end
         end
-      end
 
-      # If an attempt is made to load a decorator file, ensure the original/decorated file is loaded first.
-      # This is only supported when a decorator was not added with add_global.
-      if dep.path && sanitized_file_name.starts_with?(dep.decorator_path)
-        relative_name = sanitized_file_name.sub(dep.decorator_path, '')
-        decorated_file = "#{dep.path}#{relative_name}".sub(/#{dep.file_pattern}$/, '')
+        # If an attempt is made to load a decorator file, ensure the original/decorated file is loaded first.
+        # This is only supported when a decorator was not added with add_global.
+        if sanitized_file_name.starts_with?(decorator_path)
+          relative_name = sanitized_file_name.sub(decorator_path, '')
+          candidate_file = "#{path}#{relative_name}".sub(/#{DECORATOR_PATTERN}$/, '')
 
-        if File.file?(decorated_file + '.rb')
-          graph.add_with_edge(decorated_file, sanitized_file_name)
+          if File.file?(candidate_file + '.rb')
+            fail "File #{sanitized_file_name} is a decorator for #{candidate_file}, but this file is already
+                  decorating #{decorated_file}." unless decorated_file.nil? || decorated_file == candidate_file
+            decorated_file = candidate_file
+            decorators << sanitized_file_name
+          end
         end
       end
     end
 
-    graph.list_by_order
+    if decorated_file
+      # Decorators are sorted to ensure the load order is always the same.
+      [decorated_file] + decorators.sort
+    else
+      [sanitized_file_name]
+    end
   end
 end

data/lib/active_support_decorators/version.rb

@@ -1,3 +1,3 @@
 module ActiveSupportDecorators
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

data/spec/lib/active_support_decorators/active_support_decorator_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe ActiveSupportDecorators do
+
+  before :each do
+    # Clear class from Ruby environment.
+    ActiveSupport::Dependencies.clear
+    Object.send(:remove_const, :Pet) if defined?(Pet)
+  end
+
+  describe 'when configuring a decorator dependency' do
+    before :all do
+      original_path = File.join(File.dirname(__FILE__), 'support/originals')
+      decorator_path = File.join(File.dirname(__FILE__), 'support/decorators')
+      ActiveSupportDecorators.clear
+      ActiveSupportDecorators.add(original_path, decorator_path)
+    end
+
+    context 'and requiring the original file as .rb' do
+      it 'it loads the decorator file after loading the original' do
+        path = File.join(File.dirname(__FILE__), 'support/originals/pet.rb')
+        ActiveSupport.require_or_load(path)
+
+        Pet.new.owner.should eq('Mr. Robinson')
+      end
+    end
+
+    context 'and requiring the original file' do
+      it 'it loads the decorator file after loading the original' do
+        path = File.join(File.dirname(__FILE__), 'support/originals/pet')
+        ActiveSupport.require_or_load(path)
+
+        Pet.new.owner.should eq('Mr. Robinson')
+      end
+    end
+
+    context 'and requiring the decorator file' do
+      it 'it loads the original file first' do
+        path = File.join(File.dirname(__FILE__), 'support/decorators/pet_decorator')
+        ActiveSupport.require_or_load(path)
+
+        Pet.new.owner.should eq('Mr. Robinson')
+      end
+    end
+  end
+
+  describe 'when not using activesupport-decorators' do
+    before :all do
+      ActiveSupportDecorators.clear
+    end
+
+    it 'should not automatically load decorators' do
+      pet_path = File.join(File.dirname(__FILE__), 'support/originals/pet')
+      ActiveSupport.require_or_load(pet_path)
+
+      expect { Pet.new.owner }.to raise_error
+    end
+  end
+
+end

data/spec/lib/active_support_decorators/support/decorators/pet_decorator.rb

@@ -0,0 +1,5 @@
+Pet.class_eval do
+  def owner
+    'Mr. Robinson'
+  end
+end

data/spec/lib/active_support_decorators/support/originals/pet.rb

@@ -0,0 +1,5 @@
+class Pet
+  def bark
+    'Woof!'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'activesupport-decorators'
+
+RSpec.configure do |config|
+  # No extra config yet.
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activesupport-decorators
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Pierre Pretorius
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-01 00:00:00.000000000 Z
+date: 2014-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -49,9 +49,12 @@ files:
 - Rakefile
 - lib/active_support_decorators/active_support_decorators.rb
 - lib/active_support_decorators/dependencies_patch.rb
-- lib/active_support_decorators/graph.rb
 - lib/active_support_decorators/version.rb
 - lib/activesupport-decorators.rb
+- spec/lib/active_support_decorators/active_support_decorator_spec.rb
+- spec/lib/active_support_decorators/support/decorators/pet_decorator.rb
+- spec/lib/active_support_decorators/support/originals/pet.rb
+- spec/spec_helper.rb
 homepage: https://github.com/pierre-pretorius/activesupport-decorators
 licenses:
 - MIT

data/lib/active_support_decorators/graph.rb

@@ -1,49 +0,0 @@
-class Graph
-  Node = Struct.new(:object) do
-    def depends_on
-      @depends_on ||= []
-    end
-  end
-
-  def initialize
-    @nodes = []
-  end
-
-  def list_by_order
-    result = []
-
-    until @nodes.empty?
-      nodes_without_dependencies = @nodes.select { |n| n.depends_on.empty? }
-      result += nodes_without_dependencies.map { |n| n.object }.sort
-
-      nodes_without_dependencies.each do |to_delete|
-        @nodes.delete(to_delete)
-        @nodes.each { |n| n.depends_on.delete(to_delete) }
-      end
-    end
-
-    result
-  end
-
-  def add(object)
-    find_or_add_node(object)
-  end
-
-  def add_with_edge(from_object, to_object)
-    fail 'Can not add edge from object to itself' if from_object == to_object
-    from_node = find_or_add_node(from_object)
-    to_node = find_or_add_node(to_object)
-    to_node.depends_on << from_node
-    fail 'EMPTY' if from_node.nil?
-  end
-
-  private
-  def find_or_add_node(object)
-    node = @nodes.find { |n| n.object == object }
-    unless node
-      node = Node.new(object)
-      @nodes.push(node)
-    end
-    node
-  end
-end