activesupport-decorators 1.0.3 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4cb9f32b392ce933e327b70be427aaa08237dc0d
-  data.tar.gz: 7f91be81114a633358343e82ada2893f56490782
+  metadata.gz: ab36f5e952455f62d9a6ba3297a3b9ccf0a4a882
+  data.tar.gz: ec8df96f59cc48cefd330897491137a4b50fbbce
 SHA512:
-  metadata.gz: 98a005bb62845d66948217da89ed5cb88ce8d2b17a827a7d231769045c7355ea4ba0acba741c427a938b685f91cf531137d77d9d8f2543953156d2fb5bd54efc
-  data.tar.gz: d0d0b8847edfa8b2ed0d5b2601642860fd9d97bfc60115fd0280708ddc13ffbee4e65d15e322975adcc3456e28f4cb2e1319496ff3b85758d4002932ac2d682e
+  metadata.gz: ea6ccf8428d1eceb951baf6df41f69b9de6ae94410b108d5e475ef0b5a69b2d4be7e2edbb51a678c00f7c9cac5f08b41861a14e43239a03233396972e590b223
+  data.tar.gz: 64f9957ace96a5ac3186c06e66319d90b0e9190d564cc794c1279f38bb71c7bd72be0f45822643a8ac226f02ba1608a3acd886571c551f917c0e7abba23bd9cf

data/README.md

@@ -1,6 +1,9 @@
 ActiveSupport Decorators
 ========================
 
+[![Build Status](https://travis-ci.org/pierre-pretorius/activesupport-decorators.png?branch=master)]
+(https://travis-ci.org/pierre-pretorius/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
@@ -12,60 +15,53 @@ This is a tiny gem that provides you with a simple way to tell ActiveSupport to
 Add it to your Gemfile and run bundle install:
 
 ```Ruby
-gem 'activesupport-decorators', '~> 1.0'
+gem 'activesupport-decorators', '~> 2.0'
 ```
 
-#### Example 1 - Engine extends application class.
+### Usage
+
+#### Example 1 - Application extends engine (or any other) class.
 
-Your main rails application defines a model called Pet (in app/models/pet.rb):
+Your Rails engine defines a model called Pet (in my_engine/app/models/pet.rb):
 
 ```Ruby
 class Pet < ActiveRecord::Base
 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).  Note that you could use 'class Pet' instead
-of 'Pet.class_eval do'.
+Your Rails application now wants to adds the concept of pet owners.  You extend the Pet model in the main application
+with the following model decorator (in app/models/pet_decorator.rb).  Note that you could use 'Pet.class_eval do'
+instead of 'class Pet' if you want.
 
 ```Ruby
-Pet.class_eval do
+class Pet
   belongs_to :owner
 end
 ```
 
-Now tell ActiveSupportDecorators to load any matching decorator file in my_engine/app when a file is loaded from
-app/.  A convenient place to do this is in a Rails initializer in the engine:
+Set your ActiveSupportDecorators paths similar to setting Rails autoload paths.  This will load a decorator file if it
+matches the original file's name/path and ends with '_decorator.rb'.  In other words when the engine's app/pet.rb is
+loaded, it will load the main applications app/pet_decorator.rb.
 
 ```Ruby
-module MyEngine
-  module Rails
-    class Engine < ::Rails::Engine
-      initializer :set_decorator_dependencies do |app|
-        ActiveSupportDecorators.add("#{app.root}/app", "#{config.root}/app")
-      end
-    end
-  end
-end
+ActiveSupportDecorators.paths << File.join(Rails.application.root, 'app/**')
 ```
 
-#### Example 2 - Application extends engine class.
+Note that '**' is added to the end of the path because this is the pattern that Rails autoloads your app folder with.
+It means that every folder inside app is regarded as a autoload path instead of app/ itself, so that you can call your
+model 'Pet' and not 'Models::Pet'.
 
-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:
-
-```Ruby
-ActiveSupportDecorators.add("#{MyEngine::Rails::Engine.root}/app", "#{Rails.root}/app")
-```
+#### Example 2 - Engine extends application (or any other) class.
 
-#### Example 3 - Engine extends another engine class.
+Similar to the example above except the initializer is placed in the engine instead of the main application. The example
+below will cause any matching decorator file in my_engine/app to load when a file is loaded from app/.
 
 ```Ruby
 module MyEngine
   module Rails
     class Engine < ::Rails::Engine
-      initializer :set_decorator_dependencies do |app|
-        ActiveSupportDecorators.add("#{AnotherEngine::Rails::Engine.root}/app", "#{MyEngine::Rails::Engine.root}/app")
+      initializer :set_decorator_paths, :before => :load_environment_hook do |app|
+        ActiveSupportDecorators.paths << File.join(config.root, 'app/**')
       end
     end
   end
@@ -87,11 +83,12 @@ Other gems work by simply telling Rails to eager load all your decorators on app
 [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.
+* if you decorate two classes and one uses decorated functionality of the other, you have to make sure that it is not
+  used during class loading since the other class might not be decorated yet.
+* development mode is a bit slower since eager loading decorators 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.
+reference other classes they will be decorated on the fly when ActiveSupport loads them.

data/lib/active_support_decorators/active_support_decorators.rb

@@ -1,17 +1,18 @@
 module ActiveSupportDecorators
-  DECORATOR_PATTERN = '_decorator'
+  def self.paths
+    @paths ||= []
+  end
 
-  def self.clear
-    dependencies.clear
+  def self.pattern
+    @pattern ||= '_decorator'
   end
 
-  def self.dependencies
-    @dependencies ||= {}
+  def self.pattern=(pattern)
+    @pattern = pattern
   end
 
-  def self.add(path, decorator_path)
-    dependencies[path] ||= []
-    dependencies[path] << decorator_path
+  def self.expanded_paths
+    paths.map { |p| Dir[p] }.flatten
   end
 
   def self.debug
@@ -23,46 +24,33 @@ module ActiveSupportDecorators
   end
 
   private
-  def self.load_path_order(file_name)
-    # Do not process with .rb extension if provided.
-    sanitized_file_name = file_name.sub(/\.rb$/, '')
-    decorated_file = nil
-    decorators = []
+  def self.all_autoload_paths
+    return [] unless defined?(Rails)
+    all_modules = [::Rails.application] + ::Rails::Engine.subclasses.map(&:instance)
+    all_modules.map { |mod| mod.send(:_all_autoload_paths) }.flatten
+  end
 
-    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}"
+  def self.relative_search_path(file_name, const_path = nil)
+    file = file_name
 
-          if File.file?(candidate_file + '.rb')
-            decorated_file = sanitized_file_name
-            decorators << candidate_file
-          end
-        end
+    if const_path
+      file = const_path.underscore
+    else
+      sanitized_file_name = file_name.sub(/\.rb$/, '')
+      first_load_path_match = all_autoload_paths.find { |p| file_name.include?(p) }
+      file = sanitized_file_name.sub(first_load_path_match, '') if first_load_path_match
+    end
+    "#{file}#{pattern}.rb"
+  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 sanitized_file_name.starts_with?(decorator_path)
-          relative_name = sanitized_file_name.sub(decorator_path, '')
-          candidate_file = "#{path}#{relative_name}".sub(/#{DECORATOR_PATTERN}$/, '')
+  def self.load_path_order(file_name, const_path = nil)
+    order = [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
+    expanded_paths.each do |path|
+      candidate_file = File.join(path, relative_search_path(file_name, const_path))
+      order << candidate_file if File.file?(candidate_file)
     end
 
-    if decorated_file
-      # Decorators are sorted to ensure the load order is always the same.
-      [decorated_file] + decorators.sort
-    else
-      [sanitized_file_name]
-    end
+    order
   end
 end

data/lib/active_support_decorators/dependencies_patch.rb

@@ -1,17 +1,19 @@
 require 'active_support/dependencies'
 
-module ActiveSupport::Dependencies
-  alias_method :require_or_load_without_multiple, :require_or_load
+module ActiveSupport
+  module Dependencies
+    alias_method :require_or_load_without_multiple, :require_or_load
 
-  def require_or_load(file_name, const_path = nil)
-    order = ActiveSupportDecorators.load_path_order(file_name)
+    def require_or_load(file_name, const_path = nil)
+      order = ActiveSupportDecorators.load_path_order(file_name, const_path)
 
-    if ActiveSupportDecorators.debug && order.size > 1
-      Rails.try(:logger).try(:debug, "ActiveSupportDecorators: Loading files in order #{order.join(', ')}.")
-    end
+      if ActiveSupportDecorators.debug && order.size > 1
+        Rails.try(:logger).try(:debug, "ActiveSupportDecorators: Loading files in order #{order.join(', ')}.")
+      end
 
-    order.each do |path|
-      require_or_load_without_multiple(path, const_path)
+      order.each do |path|
+        require_or_load_without_multiple(path, const_path)
+      end
     end
   end
-end
+end

data/lib/active_support_decorators/version.rb

@@ -1,3 +1,3 @@
 module ActiveSupportDecorators
-  VERSION = '1.0.3'
+  VERSION = '2.0.1'
 end

data/spec/lib/active_support_decorators/active_support_decorator_spec.rb

@@ -3,55 +3,45 @@ require 'spec_helper'
 describe ActiveSupportDecorators do
 
   before :each do
-    # Clear class from Ruby environment.
-    ActiveSupport::Dependencies.clear
+    # Clear class from Ruby/Rails environment.
+    ActiveSupportDecorators.paths.clear
+    ActiveSupport::Dependencies.loaded.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')
+  describe 'when configuring a decorator path' do
+    before :each do
+      ActiveSupportDecorators.stub(:all_autoload_paths) do
+        [File.join(File.dirname(__FILE__), 'support', 'originals')]
       end
+
+      ActiveSupportDecorators.paths.clear
+      ActiveSupportDecorators.paths << File.join(File.dirname(__FILE__), 'support', 'decorators')
     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)
+    it 'it loads the decorator file after loading the original without const_path' do
+      path = File.join(File.dirname(__FILE__), 'support', 'originals', 'pet')
+      ActiveSupport::Dependencies.require_or_load(path)
 
-        Pet.new.owner.should eq('Mr. Robinson')
-      end
+      Pet.new.owner.should eq('Mr. Robinson')
     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)
+    it 'it loads the decorator file after loading the original with const_path' do
+      path = File.join(File.dirname(__FILE__), 'support', 'originals', 'pet')
+      ActiveSupport::Dependencies.require_or_load(path, 'Pet')
 
-        Pet.new.owner.should eq('Mr. Robinson')
-      end
+      Pet.new.owner.should eq('Mr. Robinson')
     end
   end
 
   describe 'when not using activesupport-decorators' do
     before :all do
-      ActiveSupportDecorators.clear
+      ActiveSupportDecorators.paths.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)
+      path = File.join(File.dirname(__FILE__), 'support', 'originals', 'pet')
+      ActiveSupport::Dependencies.require_or_load(path)
 
       expect { Pet.new.owner }.to raise_error
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activesupport-decorators
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 2.0.1
 platform: ruby
 authors:
 - Pierre Pretorius
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-02 00:00:00.000000000 Z
+date: 2014-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -75,8 +75,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Adds the decorator pattern to activesupport class loading.
 test_files: []
+has_rdoc: