class_loader 0.4.11 → 0.4.12

data/lib/class_loader/chained_adapter.rb

@@ -4,7 +4,7 @@ class ClassLoader::ChainedAdapter
   def initialize
     @adapters = []
   end
-  
+
   %w(
     exist?
     read
@@ -21,22 +21,28 @@ class ClassLoader::ChainedAdapter
       end
     end
   end
-  
-  def each_changed_class &block      
+
+  def each_changed_class &block
     adapters.each{|a| a.each_changed_class &block}
   end
-  
+
   def each_class &block
     adapters.each{|a| a.each_class &block}
   end
-  
+
   def clear
     adapters.each{|a| a.clear}
   end
-  
+
   def add_path *args
     adapters.each do |a|
       a.add_path *args if a.respond_to? :add_path
     end
   end
+
+  def delete_path *args
+    adapters.each do |a|
+      a.add_path *args if a.respond_to? :delete_path
+    end
+  end
 end

data/lib/class_loader/class_loader.rb

@@ -5,16 +5,16 @@ warn 'ClassLoader: working in slow, debug mode with explicit tmp file generation
 module ClassLoader
   @observers = []
   SYNC = Monitor.new
-  
-  class << self        
-    def loaded_classes; @loaded_classes ||= {} end       
-    
+
+  class << self
+    def loaded_classes; @loaded_classes ||= {} end
+
     def load_class namespace, const, reload = false
       SYNC.synchronize do
         original_namespace = namespace
         namespace = nil if namespace == Object or namespace == Module
         target_namespace = namespace
-      
+
         # Name hack (for anonymous classes)
 
         namespace = eval "#{name_hack(namespace)}" if namespace
@@ -23,24 +23,24 @@ module ClassLoader
         simple_also_tried = false
         begin
           simple_also_tried = (namespace == nil)
-        
-          if adapter.exist? class_name            
+
+          if adapter.exist? class_name
             if loaded_classes.include?(class_name) and !reload
               raise_without_self NameError, "something wrong with '#{const}' referenced from '#{original_namespace}' scope!"
             end
-            
+
             load(class_name, const)
-            
-            defined_in_home_scope = namespace ? namespace.const_defined?(const) : Object.const_defined?(const)            
-          
+
+            defined_in_home_scope = namespace ? namespace.const_defined?(const) : Object.const_defined?(const)
+
             unless defined_in_home_scope
               msg = "Class Name '#{class_name}' doesn't correspond to File Name '#{adapter.to_file_path(class_name)}'!"
               raise msg
               # raise_without_self NameError, msg
             end
-                        
+
             result = namespace ? namespace.const_get(const) : Object.const_get(const)
-          
+
             loaded_classes[class_name] = target_namespace
             notify_observers result
             return result
@@ -49,25 +49,25 @@ module ClassLoader
             class_name = namespace ? "#{namespace.name}::#{const}" : const
           end
         end until simple_also_tried
-        
+
         return false
       end
     end
-    
-    def reload_class class_name      
+
+    def reload_class class_name
       SYNC.synchronize do
         class_name = class_name.sub(/^::/, "")
         namespace = Module.namespace_for(class_name)
-        name = class_name.sub(/^#{namespace}::/, "")      
-      
+        name = class_name.sub(/^#{namespace}::/, "")
+
         # removing old class
         # class_container = (namespace || Object)
         # class_container.send :remove_const, name if class_container.const_defined? name
-      
+
         return load_class namespace, name, true
       end
     end
-      
+
     def wrap_inside_namespace namespace, script
       nesting = []
       if namespace
@@ -82,29 +82,36 @@ module ClassLoader
       ending = nesting.collect{"end"}.join('; ')
       return "#{begining}#{script} \n#{ending}"
     end
-    
-    
-    # 
+
+
+    #
     # Utilities
-    #     
-    def autoload_dir path, watch = false, start_watch_thread = true
+    #
+    def autoload_path path, watch = false, start_watch_thread = true
       hook!
       start_watching! if watch and start_watch_thread
       adapter.add_path path, watch
     end
-    
+    def autoload_dir *a, &b
+      warn 'ClassLoader: the :autoload_dir method is deprecated, please use :autoload_path'
+      autoload_path *a, &b
+    end
+    def delete_path path
+      adapter.delete_path path
+    end
+
     def clear
       self.adapter = nil
       self.observers = []
       # self.error_on_defined_constant = false
     end
-    
-    attr_accessor :observers    
+
+    attr_accessor :observers
     def add_observer &block; observers << block end
     def notify_observers o
       observers.each{|obs| obs.call o}
     end
-    
+
     def hook!
       return if @hooked
 
@@ -117,32 +124,32 @@ module ClassLoader
           else
             const_missing_without_class_loader const
           end
-        end        
+        end
       end
       @hooked = true
     end
-    
+
     attr_writer :adapter
     def adapter
       @adapter ||= default_adapter
     end
-    
-    
-    # 
+
+
+    #
     # Watcher thread
-    # 
+    #
     attr_accessor :watch_interval
     def start_watching!
       # reloading doesn works in debug mode, because we by ourself are generating tmp source files
       return if defined?(CLASS_LOADER_GENERATE_TMP_FILES)
-        
-      unless @watching_thread      
-        @watching_thread = Thread.new do        
+
+      unless @watching_thread
+        @watching_thread = Thread.new do
           while true
             sleep(watch_interval || 2)
             adapter.each_changed_class do |class_name|
               puts "reloading #{class_name}"
-              reload_class class_name              
+              reload_class class_name
             end
           end
         end
@@ -155,32 +162,32 @@ module ClassLoader
         @watching_thread = nil
       end
     end
-    
+
     def preload!
       adapter.each_class do |class_name|
         reload_class class_name
       end
     end
-    
-    
+
+
     protected
       def default_adapter
-        adapter = ChainedAdapter.new        
+        adapter = ChainedAdapter.new
         adapter.adapters << FileSystemAdapter.new(UnderscoredTranslator)
-        adapter.adapters << FileSystemAdapter.new(CamelCaseTranslator)      
-        adapter        
+        adapter.adapters << FileSystemAdapter.new(CamelCaseTranslator)
+        adapter
       end
-      
-      def load class_name, const   
+
+      def load class_name, const
         script = adapter.read class_name
-        script = wrap_inside_namespace Module.namespace_for(class_name), script          
+        script = wrap_inside_namespace Module.namespace_for(class_name), script
         file_path = adapter.to_file_path(class_name)
 
         # sometimes we need to generate file explicitly
         # for example evaluated code will not be shown in Ruby coverage tool
         unless defined?(CLASS_LOADER_GENERATE_TMP_FILES)
           eval script, TOPLEVEL_BINDING, file_path
-        else          
+        else
           if file_path =~ /\.rb$/
             tmp_file_path = file_path.sub /\.rb$/, '.cltmp.rb'
             begin
@@ -194,12 +201,12 @@ module ClassLoader
           end
         end
       end
-      
+
       def raise_without_self exception, message
         raise exception, message, caller.select{|path| path !~ /\/lib\/class_loader\// and path !~ /monitor\.rb/}
       end
-    
-      def name_hack namespace        
+
+      def name_hack namespace
         if namespace
           result = namespace.to_s.gsub("#<Class:", "").gsub(">", "")
           result =~ /^\d/ ? "" : result

data/lib/class_loader/file_system_adapter/camel_case_translator.rb

@@ -3,12 +3,12 @@ class ClassLoader::CamelCaseTranslator
     raise "internall error, invalid format for #{normalized_file_name}!" if normalized_file_name =~ /^\//
     normalized_file_name.gsub('/', '::')
   end
-  
+
   def self.to_file_path class_name
     raise "internall error, invalid format for #{class_name}!" if class_name =~ /^::/
     class_name.gsub('::', '/')
   end
-  
+
   def self.is_it_class? normalized_file_name
     raise "internall error, invalid format for #{normalized_file_name}!" if normalized_file_name =~ /^\//
     normalized_file_name[0..0] =~ /[A-Z]/

data/lib/class_loader/file_system_adapter/underscored_translator.rb

@@ -3,12 +3,12 @@ module ClassLoader::UnderscoredTranslator
     raise "internall error, invalid format for #{normalized_file_name}!" if normalized_file_name =~ /^\//
     normalized_file_name.camelize
   end
-  
+
   def self.to_file_path class_name
     raise "internall error, invalid format for #{class_name}!" if class_name =~ /^::/
     class_name.underscore
   end
-  
+
   def self.is_it_class? normalized_file_name
     raise "internall error, invalid format for #{normalized_file_name}!" if normalized_file_name =~ /^\//
     normalized_file_name[0..0] =~ /[a-z]/

data/lib/class_loader/file_system_adapter.rb

@@ -1,28 +1,28 @@
 class ClassLoader::FileSystemAdapter
   attr_reader :translator
-  
-  def initialize class_name_translator      
+
+  def initialize class_name_translator
     @translator = class_name_translator
     @paths, @watched_paths, @file_name_cache = [], [], {}
     @watched_files, @first_check = {}, true
   end
-  
+
   def exist? class_name
     !!to_file_path(class_name)
   end
   alias_method :exists?, :exist?
-  
-  def read class_name      
+
+  def read class_name
     file_path = to_file_path class_name
     return nil unless file_path
-    
+
     if file_path =~ /\.rb$/
-      File.open(file_path){|f| f.read}        
+      File.open(file_path){|f| f.read}
     else
       "module #{class_name}; end;"
-    end  
+    end
   end
-  
+
   def to_file_path class_name
     file_path, exist = @file_name_cache[class_name] || []
     unless exist
@@ -35,7 +35,7 @@ class ClassLoader::FileSystemAdapter
             throw :found, try
           end
         end
-        
+
         # dirs
         paths.each do |base|
           try = "#{base}/#{normalized_name}"
@@ -43,21 +43,21 @@ class ClassLoader::FileSystemAdapter
             throw :found, try
           end
         end
-        
+
         nil
       end
-      @file_name_cache[class_name] = [file_path, true]        
+      @file_name_cache[class_name] = [file_path, true]
     end
     file_path
   end
-  
+
   def to_class_name normalized_path
-    raise "Internal error, file_name should be absolute path (#{normalized_path})!" unless normalized_path =~ /^\//  
-    raise "Internal error, file_name should be without .rb suffix (#{normalized_path})!" if normalized_path =~ /\.rb$/  
-    
-    paths.each do |base_path| 
+    raise "Internal error, file_name should be absolute path (#{normalized_path})!" unless normalized_path =~ /^\//
+    raise "Internal error, file_name should be without .rb suffix (#{normalized_path})!" if normalized_path =~ /\.rb$/
+
+    paths.each do |base_path|
       if normalized_path.start_with? base_path
-        normalized_name = normalized_path.sub(base_path + '/', '')          
+        normalized_name = normalized_path.sub(base_path + '/', '')
         if translator.is_it_class? normalized_name
           return translator.to_class_name(normalized_name)
         end
@@ -65,8 +65,8 @@ class ClassLoader::FileSystemAdapter
     end
     nil
   end
-  
-  def add_path base_path, watch = false      
+
+  def add_path base_path, watch = false
     base_path = File.expand_path(base_path)
     # raise "#{base_path} already added!" if paths.include? base_path
     unless paths.include? base_path
@@ -74,59 +74,65 @@ class ClassLoader::FileSystemAdapter
       watched_paths << base_path if watch
     end
   end
-  
+
+  def delete_path path
+    path = File.expand_path(path)
+    paths.delete path
+    watched_paths.delete path
+  end
+
   def clear
     @paths, @watched_paths, @file_name_cache = [], [], {}
     @watched_files, @first_check = {}, true
-  end    
-      
+  end
+
   def each_changed_class &block
     unless @first_check == @watched_paths
       @first_check = @watched_paths.clone
       each_watched_file{|file_path, file_name| remember_file file_path}
-    else        
+    else
       each_watched_file do |file_path, file_name|
         if file_changed? file_path
           remember_file file_path
-          
+
           normalized_name = file_name.sub(/\.rb$/, "")
           block.call translator.to_class_name(normalized_name)
         end
-      end 
-    end      
+      end
+    end
   end
-  
+
   def each_class &block
-    @paths.each do |base_path|          
+    @paths.each do |base_path|
       Dir.glob("#{base_path}/**/*.rb").each do |file_path|
         normalized_path = file_path.sub(/\.rb$/, "")
-        
+
         normalized_name = normalized_path.sub(base_path + "/", '')
         class_name = translator.to_class_name(normalized_name)
         block.call class_name
       end
     end
   end
-  
+
   def each_watched_file &block
-    @watched_paths.each do |base_path|          
+    @watched_paths.each do |base_path|
       Dir.glob("#{base_path}/**/*.rb").each do |file_path|
         file_name = file_path.sub(base_path + '/', '')
 
-        if translator.is_it_class? file_name            
+        if translator.is_it_class? file_name
           block.call file_path, file_name
         end
       end
     end
   end
-  
+
   def inspect
     "FileSystemAdapter (#{@paths.join(', ')})"
-  end      
-  
+  end
+
   protected
-    attr_reader :paths, :watched_paths, :watcher, :watched_files      
-    
+    attr_reader :paths, :watched_paths, :watcher, :watched_files
+
     def file_changed? file_path
       old_time = watched_files[file_path]
       old_time == nil or old_time != File.mtime(file_path)
@@ -135,5 +141,5 @@ class ClassLoader::FileSystemAdapter
     def remember_file file_path
       watched_files[file_path] = File.mtime(file_path)
     end
-    
+
 end

data/lib/class_loader/spec.rb

@@ -0,0 +1,17 @@
+require 'rspec_ext'
+
+rspec do
+  def self.with_autoload_path *paths
+    before(:all){paths.each{|path| ClassLoader.autoload_path path}}
+    after(:all){paths.each{|path| ClassLoader.delete_path path}}
+  end
+
+  def with_autoload_path *paths, &b
+    begin
+      paths.each{|path| ClassLoader.autoload_path path}
+      b.call
+    ensure
+      paths.each{|path| ClassLoader.delete_path path}
+    end
+  end
+end

data/lib/class_loader/support.rb

@@ -10,7 +10,7 @@ class String
       word
     end
   end
-  
+
   unless method_defined? :camelize
     def camelize first_letter_in_uppercase = true
       if first_letter_in_uppercase

data/lib/class_loader.rb

@@ -7,11 +7,15 @@ end
   support
   file_system_adapter/camel_case_translator
   file_system_adapter/underscored_translator
-  file_system_adapter  
+  file_system_adapter
   chained_adapter
   class_loader
 ).each{|f| require "class_loader/#{f}"}
 
-def autoload_dir *args, &block
-  ClassLoader.autoload_dir *args, &block
-end 
+def autoload_path *args, &block
+  ClassLoader.autoload_path *args, &block
+end
+def autoload_dir *a, &b
+  warn 'ClassLoader: the :autoload_dir method is deprecated, please use :autoload_path'
+  autoload_path *a, &b
+end

data/readme.md

@@ -1,45 +1,45 @@
 # Automatically finds and loads classes for Your Ruby App
 
 ## Overview
-There's only one method - :autoload_dir, kind of turbocharged :autoload, it understands namespaces, figure out dependencies and can watch and reload changed files.
+There's only one method - :autoload_path, kind of turbocharged :autoload, it understands namespaces, figure out dependencies and can watch and reload changed files.
 
-Let's say your application has the following structure
+Let's say Your application has the following structure
 
 	/your_app
-		/lib			
+		/lib
 			/animals
 				/dog.rb
 			/zoo.rb
 
-Just point ClassLoader to the directory(ies) your classes are located and it will find and load them automatically
+Just point ClassLoader to the directory(ies) Your classes are located and it will find and load them automatically
 
 	require 'class_loader'
-	autoload_dir '/your_app/lib'
-	
+	autoload_path '/your_app/lib'
+
 	Zoo.add Animals::Dog.new # <= all classes loaded automatically
-	
+
 no need for
 
 	# require 'animals/dog'
 	# require 'app'
-	
+
 you can specify multiple autoload directories, and tell it to watch them
 
-	autoload_dir '/your_app/lib', true # <= provide true as the second argument
-	autoload_dir '/your_app/another_lib'	
-	
+	autoload_path '/your_app/lib', true # <= provide true as the second argument
+	autoload_path '/your_app/another_lib'
+
 **Note**: In the dog.rb we write just the "class Dog; end", instead of "module Animals; class Dog; end; end', and there are no really the 'Animals' module, ClassLoader smart enough to figure it out that there's should be one by looking at files structure and it will generate it on the fly.
 
-Also you can use CamelCase notation or provide your own class_name/file_path translator, or even provide your own custom resource adapter that for example will look for classes on the net and download them.
+Also you can use CamelCase notation or provide Your own class_name/file_path translator, or even provide Your own custom resource adapter that for example will look for classes on the net and download them.
 
-There's currently a known bug in Ruby 1.8.x - class loading isn't thread safe, so in production you should preload all your classes
+There's currently a known bug in Ruby 1.8.x - class loading isn't thread safe, so in production you should preload all Your classes
 
 	ClassLoader.preload! if app_in_production?
 
 ## Installation
 
 	$ gem install class_loader
-	
-## Please let me know about bugs and your proposals, there's the 'Issues' tab at the top, feel free to submit.
-	
-Copyright (c) Alexey Petrushin http://4ire.net, released under the MIT license.
+
+## License
+
+Copyright (c) Alexey Petrushin http://petrush.in, released under the MIT license.

data/spec/class_loader_spec/underscored/underscored_namespace/underscored_class.rb

@@ -1,2 +1,2 @@
 class UnderscoredClass
-end 
+end

data/spec/class_loader_spec/unload_old_class/UnloadOldClass.rb

@@ -1,2 +1,2 @@
-class UnloadOldClass  
+class UnloadOldClass
 end

data/spec/class_loader_spec.rb

@@ -1,9 +1,9 @@
 require 'rspec_ext'
 require "class_loader"
 
-describe ClassLoader do  
+describe ClassLoader do
   with_tmp_spec_dir
-  
+
   after :all do
     remove_constants %w(
       BasicSpec
@@ -18,51 +18,51 @@ describe ClassLoader do
       UnderscoredNamespace
     )
   end
-  
+
   after do
     ClassLoader.clear
   end
-  
+
   it "should load classes from class path" do
-    autoload_dir "#{spec_dir}/basic"
-    
+    autoload_path "#{spec_dir}/basic"
+
     BasicSpec
     BasicSpec::SomeNamespace::SomeClass
   end
-    
+
   it "should load classes only once" do
-    autoload_dir "#{spec_dir}/only_once"
-    
+    autoload_path "#{spec_dir}/only_once"
+
     check = mock
     check.should_receive(:loaded).once
     ClassLoader.add_observer do |klass|
       klass.name.should == "OnlyOnceSpec"
       check.loaded
     end
-    
+
     OnlyOnceSpec
     OnlyOnceSpec
   end
-  
+
   it "should resolve is namespace a class or module" do
-    autoload_dir "#{spec_dir}/namespace_type_resolving"
-    
+    autoload_path "#{spec_dir}/namespace_type_resolving"
+
     NamespaceTypeResolving.class.should == Class
     NamespaceTypeResolving::SomeClass
-    
-    class NamespaceIsAlreadyDefinedAsClass; end    
+
+    class NamespaceIsAlreadyDefinedAsClass; end
     NamespaceIsAlreadyDefinedAsClass::SomeClass
   end
-  
+
   it "should recognize infinity loop" do
-    autoload_dir "#{spec_dir}/infinity_loop"
-    
+    autoload_path "#{spec_dir}/infinity_loop"
+
     -> {InfinityLoop}.should raise_error(/Class Name .+ doesn't correspond to File Name/)
   end
-  
+
   it "should correctly works inside of anonymous class" do
-    autoload_dir "#{spec_dir}/anonymous_class"
-    
+    autoload_path "#{spec_dir}/anonymous_class"
+
     module ::AnonymousSpec
       class << self
         def anonymous
@@ -70,13 +70,13 @@ describe ClassLoader do
         end
       end
     end
-    
+
     AnonymousSpec.anonymous
   end
-  
+
   it "should raise exception if class defined in another namespace" do
-    autoload_dir "#{spec_dir}/another_namespace"
-    
+    autoload_path "#{spec_dir}/another_namespace"
+
     AnotherNamespace::NamespaceA
     # ClassLoader.error_on_defined_constant = true
     -> {
@@ -84,21 +84,21 @@ describe ClassLoader do
     }.should raise_error(/something wrong with/)
     # }.should raise_error(/Class '.+' is not defined in the '.+' Namespace!/)
   end
-  
-  describe "reloading" do  
+
+  describe "reloading" do
     it "should reload class files" do
       class_reloading_dir = "#{spec_dir}/class_reloading"
       fname = "#{class_reloading_dir}/ClassReloadingSpec.rb"
-      autoload_dir class_reloading_dir
+      autoload_path class_reloading_dir
 
       code = <<-RUBY
 class ClassReloadingSpec
   def self.check; :value end
 end
 RUBY
-    
+
       File.open(fname, 'w'){|f| f.write code}
-    
+
       ClassReloadingSpec.check.should == :value
 
       code = <<-RUBY
@@ -108,30 +108,30 @@ end
 RUBY
 
       File.open(fname, 'w'){|f| f.write code}
-    
+
       ClassLoader.reload_class(ClassReloadingSpec.name)
       ClassReloadingSpec.check.should == :another_value
     end
 
-    # Outdated  
+    # Outdated
     # it "should unload old classes before reloading" do
-    #   autoload_dir "#{spec_dir}/unload_old_class"
+    #   autoload_path "#{spec_dir}/unload_old_class"
     #   UnloadOldClass.instance_variable_set "@value", :value
     #   ClassLoader.reload_class(UnloadOldClass.name)
     #   UnloadOldClass.instance_variable_get("@value").should == nil
     # end
   end
-  
+
   it "should be able to preload all classes in production" do
-    autoload_dir "#{spec_dir}/preloading"
-    Object.const_defined?(:PreloadingSpec).should be_false    
+    autoload_path "#{spec_dir}/preloading"
+    Object.const_defined?(:PreloadingSpec).should be_false
     ClassLoader.preload!
     Object.const_defined?(:PreloadingSpec).should be_true
-  end  
-  
+  end
+
   it "underscored smoke test" do
-    autoload_dir "#{spec_dir}/underscored"
-    
+    autoload_path "#{spec_dir}/underscored"
+
     UnderscoredNamespace::UnderscoredClass
   end
 end

data/spec/file_system_adapter_spec.rb

@@ -1,109 +1,109 @@
 require "rspec_ext"
 require "class_loader"
 
-describe ClassLoader::FileSystemAdapter do  
+describe ClassLoader::FileSystemAdapter do
   with_tmp_spec_dir
-  
+
   before do
-    @fs_adapter = ClassLoader::FileSystemAdapter.new(ClassLoader::CamelCaseTranslator)    
-    
+    @fs_adapter = ClassLoader::FileSystemAdapter.new(ClassLoader::CamelCaseTranslator)
+
     # Actually we are testing both ChainedAdapter and FileSystemAdapter
     @adapter = ClassLoader::ChainedAdapter.new
     @adapter.adapters << @fs_adapter
-    
-    @adapter.add_path "#{spec_dir}/common"    
+
+    @adapter.add_path "#{spec_dir}/common"
   end
-  
+
   def write_file path, klass
     File.open("#{spec_dir}/#{path}", 'w'){|f| f.write "class #{klass}; end"}
   end
-  
+
   it "exist?" do
     @adapter.exist?("SomeNamespace").should be_true
-    @adapter.exist?("SomeNamespace::SomeClass").should be_true    
+    @adapter.exist?("SomeNamespace::SomeClass").should be_true
     @adapter.exist?("SomeNamespace::NonExistingClass").should be_false
   end
-  
+
   it "should works with multiple class paths" do
     @adapter.add_path "#{spec_dir}/multiple_class_paths/path_a"
     @adapter.add_path "#{spec_dir}/multiple_class_paths/path_b"
-      
+
     @adapter.exist?("ClassInPathA").should be_true
     @adapter.exist?("ClassInPathB").should be_true
   end
-  
+
   it "read" do
-    @adapter.read("SomeNamespace::SomeClass").should == "class SomeClass; end" 
+    @adapter.read("SomeNamespace::SomeClass").should == "class SomeClass; end"
   end
-  
+
   it "to_file_path" do
     @adapter.to_file_path("NonExistingClass").should be_nil
     @adapter.to_file_path("SomeNamespace::SomeClass").should =~ /SomeNamespace\/SomeClass/
   end
-  
+
   it "to_class_name" do
     @adapter.to_class_name("#{spec_dir}/non_existing_path").should be_nil
     @adapter.to_class_name("#{spec_dir}/common/SomeNamespace").should == "SomeNamespace"
     @adapter.to_class_name("#{spec_dir}/common/SomeNamespace/SomeClass").should == "SomeNamespace::SomeClass"
   end
-  
+
   it "shouldn't add path twice" do
     @adapter.clear
     @adapter.add_path "#{spec_dir}/common"
     @adapter.add_path "#{spec_dir}/common"
     @fs_adapter.instance_variable_get("@paths").size.should == 1
   end
-  
-  describe "file watching" do      
+
+  describe "file watching" do
     def changed_classes
       changed = []
       @adapter.each_changed_class{|c| changed << c}
       changed
     end
-    
+
     it "each_changed_class shouldn't affect paths not specified for watching" do
       @adapter.add_path "#{spec_dir}/search_only_watched", false
-      changed_classes.should == []        
-      
+      changed_classes.should == []
+
       sleep(1) && write_file("watching/SomeClass.rb", "SomeClass")
       changed_classes.should == []
     end
-      
+
     it "each_changed_class" do
       @adapter.add_path "#{spec_dir}/watching", true
-      
-      changed_classes.should == []        
-    
-      sleep(1) && write_file("watching/SomeClass.rb", "SomeClass")      
+
+      changed_classes.should == []
+
+      sleep(1) && write_file("watching/SomeClass.rb", "SomeClass")
       changed_classes.should == ["SomeClass"]
-    
+
       sleep(1) && write_file("watching/SomeClass.rb", "SomeClass")
       changed_classes.should == ["SomeClass"]
     end
   end
-  
+
   describe "Underscored shouldn't mess with CamelCase" do
     before do
-      @camel_case_adapter = ClassLoader::FileSystemAdapter.new(ClassLoader::CamelCaseTranslator)      
+      @camel_case_adapter = ClassLoader::FileSystemAdapter.new(ClassLoader::CamelCaseTranslator)
       @camel_case_adapter.add_path "#{spec_dir}/shouldnt_mess", true
       @camel_case_file_path = "#{spec_dir}/shouldnt_mess/CamelCaseClass.rb"
-      
-      @underscored_adapter = ClassLoader::FileSystemAdapter.new(ClassLoader::UnderscoredTranslator)  
+
+      @underscored_adapter = ClassLoader::FileSystemAdapter.new(ClassLoader::UnderscoredTranslator)
       @underscored_adapter.add_path "#{spec_dir}/shouldnt_mess", true
       @underscored_file_path = "#{spec_dir}/shouldnt_mess/underscored_class.rb"
     end
-    
-    
-    it "should watch only files understable by it's translator (CamelCase shouldn't load Underscored)" do      
+
+
+    it "should watch only files understable by it's translator (CamelCase shouldn't load Underscored)" do
       watched = []
       @camel_case_adapter.each_watched_file{|file_path, relative_name| watched << relative_name}
       watched.should == ["CamelCaseClass.rb"]
-            
+
       watched = []
       @underscored_adapter.each_watched_file{|file_path, relative_name| watched << relative_name}
       watched.should == ["underscored_class.rb"]
     end
-    
+
     it "CamelCase to_class_name shouldn't translate Underscored" do
       @camel_case_adapter.to_class_name(@camel_case_file_path.sub(/\.rb$/, '')).should == "CamelCaseClass"
       @underscored_adapter.to_class_name(@underscored_file_path.sub(/\.rb$/, '')).should == "UnderscoredClass"

data/spec/translators_spec.rb

@@ -7,26 +7,26 @@ describe "Translators" do
     before :all do
       @t = ClassLoader::CamelCaseTranslator
     end
-    
+
     it "is_it_class?" do
       @t.is_it_class?("SomeClass.rb").should be_true
       @t.is_it_class?("SomeNamespace/SomeClass.rb").should be_true
-      
+
       @t.is_it_class?("someclass.rb").should be_false
       @t.is_it_class?("some_class.rb").should be_false
       @t.is_it_class?("some_namespace/some_class.rb").should be_false
     end
   end
-  
+
   describe "Underscored" do
     before :all do
       @t = ClassLoader::UnderscoredTranslator
     end
-    
+
     it "is_it_class?" do
       @t.is_it_class?("SomeClass.rb").should be_false
       @t.is_it_class?("SomeNamespace/SomeClass.rb").should be_false
-      
+
       @t.is_it_class?("someclass.rb").should be_true
       @t.is_it_class?("some_class.rb").should be_true
       @t.is_it_class?("some_namespace/some_class.rb").should be_true

metadata

@@ -1,28 +1,22 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: class_loader
-version: !ruby/object:Gem::Version 
-  version: 0.4.11
+version: !ruby/object:Gem::Version
+  version: 0.4.12
   prerelease: 
 platform: ruby
-authors: 
+authors:
 - Alexey Petrushin
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-08-08 00:00:00 +04:00
-default_executable: 
+date: 2011-08-15 00:00:00.000000000Z
 dependencies: []
-
 description: 
 email: 
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - Rakefile
 - readme.md
 - lib/class_loader/chained_adapter.rb
@@ -30,6 +24,7 @@ files:
 - lib/class_loader/file_system_adapter/camel_case_translator.rb
 - lib/class_loader/file_system_adapter/underscored_translator.rb
 - lib/class_loader/file_system_adapter.rb
+- lib/class_loader/spec.rb
 - lib/class_loader/support.rb
 - lib/class_loader/tasks.rb
 - lib/class_loader.rb
@@ -54,33 +49,28 @@ files:
 - spec/file_system_adapter_spec/shouldnt_mess/underscored_class.rb
 - spec/file_system_adapter_spec.rb
 - spec/translators_spec.rb
-has_rdoc: true
 homepage: http://github.com/alexeypetrushin/class_loader
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.1
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Automatically finds, loads and reloads classes
 test_files: []
-