class-loader 0.3.1

data/Rakefile

@@ -0,0 +1,60 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+Dir.chdir File.dirname(__FILE__)	
+
+# Specs
+task :default => :spec
+
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_files = FileList["spec/**/*_spec.rb"].select{|f| f !~ /\/_/}
+  t.libs = ['lib'].collect{|f| "#{File.dirname __FILE__}/#{f}"}
+  # t.spec_opts = ["--backtrace"]
+end
+
+# Gem
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'fileutils'
+
+spec = Gem::Specification.new do |s|
+  s.name = "class-loader"
+  s.version = "0.3.1" 
+  s.summary = "Makes any directory looks like Ruby Gem"
+  s.description = "Makes any directory looks like Ruby Gem"
+  s.author = "Alexey Petrushin"
+  # s.email = ""
+  s.homepage = "http://github.com/alexeypetrushin/class-loader"
+  
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  
+  s.files = (['Rakefile', 'readme.md'] + Dir.glob("{lib,spec}/**/*"))
+  
+  s.require_paths = ["lib"]
+end
+
+PACKAGE_DIR = "#{File.expand_path File.dirname(__FILE__)}/build"
+
+Rake::GemPackageTask.new(spec) do |p|
+  package_dir = PACKAGE_DIR
+# FileUtils.mkdir package_dir unless File.exist? package_dir  
+  p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+  p.need_zip = true
+  p.package_dir = package_dir
+end
+
+# CLEAN.include [ 'pkg', '*.gem']
+
+task :push do
+  dir = Dir.chdir PACKAGE_DIR do
+    gem_file = Dir.glob("class-loader*.gem").first
+    system "gem push #{gem_file}"
+  end
+end
+
+task :clean do
+  system "rm -r #{PACKAGE_DIR}"
+end
+
+task :release => [:gem, :push, :clean] 

data/lib/class_loader.rb

@@ -0,0 +1,12 @@
+%w(
+  support
+  file_system_adapter/camel_case_translator
+  file_system_adapter/underscored_translator
+  file_system_adapter  
+  chained_adapter
+  class_loader
+).each{|f| require "class_loader/#{f}"}
+
+def autoload_dir *args, &block
+  ClassLoader.autoload_dir *args, &block
+end 

data/lib/class_loader/chained_adapter.rb

@@ -0,0 +1,44 @@
+module ClassLoader
+  class ChainedAdapter
+    attr_accessor :adapters
+
+    def initialize
+      @adapters = []
+    end
+    
+    %w(
+      exist?
+      read
+      to_file_path
+      to_class_name
+    ).each do |method|
+      define_method method do |*args|
+        catch :found do
+          adapters.each do |a|
+            value = a.send method, *args
+            throw :found, value if value
+          end
+          nil
+        end
+      end
+    end
+    
+    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
+  end
+end

data/lib/class_loader/class_loader.rb

@@ -0,0 +1,219 @@
+require 'monitor'
+
+module ClassLoader
+  @observers = []
+  SYNC = Monitor.new
+  
+  class << self        
+    # 
+    # Class loading logic
+    # 
+    attr_accessor :error_on_defined_constant
+    def loaded_classes; @loaded_classes ||= {} end            
+    
+    def load_class namespace, const, reload = false            
+      SYNC.synchronize do
+        namespace = nil if namespace == Object or namespace == Module
+        target_namespace = namespace
+      
+        # Name hack (for anonymous classes)
+        namespace = eval "#{name_hack(namespace)}" if namespace
+      
+        class_name = namespace ? "#{namespace.name}::#{const}" : const
+        simple_also_tried = false
+        begin
+          simple_also_tried = (namespace == nil)
+        
+          if try_load(class_name, 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_without_self NameError, msg
+            end
+                        
+            unless reload
+              if loaded_classes.include? class_name
+                if error_on_defined_constant  
+                  raise_without_self NameError, "Class '#{class_name}' is not defined in the '#{target_namespace}' Namespace!"
+                else
+                  warn "Warn: Class '#{class_name}' is not defined in the '#{target_namespace}' Namespace!"
+                  puts caller
+                end
+              end
+            end
+            
+            result = namespace ? namespace.const_get(const) : Object.const_get(const)
+          
+            loaded_classes[class_name] = target_namespace
+            notify_observers result
+            return result
+          elsif namespace
+            namespace = Module.namespace_for(namespace.name)
+            class_name = namespace ? "#{namespace.name}::#{const}" : const
+          end
+        end until simple_also_tried
+        
+        raise_without_self NameError, "uninitialized constant '#{class_name}'!"
+      end
+    end
+    
+    def reload_class class_name
+      SYNC.synchronize do
+        class_name = class_name.sub(/^::/, "")
+        namespace = Module.namespace_for(class_name)
+        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
+        current_scope = ""
+        namespace.name.split("::").each do |level|
+          current_scope += "::#{level}"
+          type = eval current_scope, TOPLEVEL_BINDING, __FILE__, __LINE__
+          nesting << [level, (type.class == Module ? "module" : "class")]
+        end
+      end
+      begining = nesting.collect{|l, t| "#{t} #{l};"}.join(' ')
+      ending = nesting.collect{"end"}.join('; ')
+      return "#{begining}#{script} \n#{ending}"
+    end
+    
+    
+    # 
+    # Utilities
+    #     
+    def autoload_dir path, watch = false, start_watch_thread = true
+      hook!
+      start_watching! if watch and start_watch_thread
+      adapter.add_path path, watch
+    end
+    
+    def clear
+      self.adapter = nil
+      self.observers = []
+      self.error_on_defined_constant = false
+    end
+    
+    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
+
+      ::Module.class_eval do
+        alias_method :const_missing_without_cl, :const_missing
+        def const_missing const
+          return ClassLoader.load_class self, const.to_s
+        end
+      end
+      @hooked = true
+    end
+    
+    attr_writer :adapter
+    def adapter
+      @adapter ||= default_adapter
+    end
+    
+    
+    # 
+    # Watcher thread
+    # 
+    attr_accessor :watch_interval
+    def start_watching!
+      unless watching_thread      
+        self.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              
+            end
+          end
+        end
+      end
+    end
+
+    def stop_watching!
+      if watching_thread
+        watching_thread.kill
+        self.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.adapters << FileSystemAdapter.new(CamelCaseTranslator)    
+        adapter.adapters << FileSystemAdapter.new(UnderscoredTranslator)
+        adapter        
+      end
+      
+      def try_load class_name, const
+        if adapter.exist? class_name
+          script = adapter.read class_name
+          script = wrap_inside_namespace Module.namespace_for(class_name), script          
+          file_path = adapter.to_file_path(class_name)          
+          eval script, TOPLEVEL_BINDING, file_path
+        else
+          return false
+        end
+        return true
+      end
+      
+      def raise_without_self exception, message
+        raise exception, message, caller.select{|path| path !~ /\/lib\/class_loader\//}
+      end
+    
+      def name_hack namespace
+        if namespace
+          namespace.to_s.gsub("#<Class:", "").gsub(">", "")
+        else
+          ""
+        end
+        # Namespace Hack description
+        # Module.name doesn't works correctly for Anonymous classes.
+        # try to execute this code:
+        #
+        #class Module
+        #  def const_missing const
+        #    p self.to_s
+        #  end
+        #end
+        #
+        #class A
+        #    class << self
+        #        def a
+        #            p self
+        #            MissingConst
+        #        end
+        #    end
+        #end
+        #
+        #A.a
+        #
+        # the output will be:
+        # A
+        # "#<Class:A>"
+        #
+      end
+  end
+end

data/lib/class_loader/file_system_adapter.rb

@@ -0,0 +1,130 @@
+module ClassLoader
+  class FileSystemAdapter
+    attr_reader :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      
+      file_path = to_file_path class_name
+      return nil unless file_path
+      
+      if file_path =~ /\.rb$/
+        File.open(file_path){|f| f.read}        
+      else
+        "module #{class_name}; end;"
+      end  
+    end
+    
+    def to_file_path class_name
+      file_path, exist = @file_name_cache[class_name] || []
+      unless exist
+        file_name = translator.to_file_path class_name
+        file_path = catch :found do
+          # files
+          paths.each do |base|
+            try = "#{base}/#{file_name}.rb"
+            if File.exist? try
+              throw :found, try
+            end
+          end
+          
+          # dirs
+          paths.each do |base|
+            try = "#{base}/#{file_name}"
+            if File.exist? try
+              throw :found, try
+            end
+          end
+          
+          nil
+        end
+        
+        @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$/  
+      
+      if base_path = paths.find{|path| normalized_path.start_with? path}
+        _to_class_name normalized_path, base_path
+      else
+        nil
+      end
+    end
+    
+    def add_path path, watch = false      
+      path = File.expand_path(path)
+      raise "#{path} already added!" if paths.include? path
+      
+      paths << path
+      watched_paths << path if watch
+    end
+    
+    def clear
+      @paths, @watched_paths, @file_name_cache = [], [], {}
+      @watched_files, @first_check = {}, true
+    end    
+        
+    def each_changed_class &block
+      if @first_check
+        each_watched_file{|base_path, file_path| remember_file file_path}
+        @first_check = false
+      else
+        each_watched_file do |base_path, file_path|
+          if file_changed? file_path
+            remember_file file_path
+            
+            normalized_path = file_path.sub(/\.rb$/, "")
+            block.call _to_class_name(normalized_path, base_path)
+          end
+        end
+      end      
+    end
+    
+    def each_class &block
+      @paths.each do |base_path|          
+        Dir.glob("#{base_path}/**/*.rb").each do |file_path|
+          normalized_path = file_path.sub(/\.rb$/, "")
+          block.call _to_class_name(normalized_path, base_path)
+        end
+      end
+    end
+    
+    protected
+      attr_reader :paths, :watched_paths, :watcher, :watched_files
+      
+      def each_watched_file &block
+        @watched_paths.each do |base_path|          
+          Dir.glob("#{base_path}/**/*.rb").each do |file_path|
+            block.call base_path, file_path
+          end
+        end
+      end
+      
+      def file_changed? path        
+        old_time = watched_files[path]
+        old_time == nil or old_time != File.mtime(path)
+      end
+
+      def remember_file path
+        watched_files[path] = File.mtime(path)
+      end
+      
+      def _to_class_name file_path, base_path
+        relative_name = file_path.sub(base_path, '')
+        translator.to_class_name(relative_name)
+      end
+  end
+end

data/lib/class_loader/file_system_adapter/camel_case_translator.rb

@@ -0,0 +1,11 @@
+module ClassLoader
+  class CamelCaseTranslator
+    def self.to_class_name file_path
+      file_path.sub(/^\//, '').gsub('/', '::')
+    end
+    
+    def self.to_file_path class_name
+      class_name.sub(/^::/, '').gsub('::', '/')
+    end
+  end
+end

data/lib/class_loader/file_system_adapter/underscored_translator.rb

@@ -0,0 +1,11 @@
+module ClassLoader
+  class UnderscoredTranslator
+    def self.to_class_name file_path
+      file_path.sub(/^\//, '').camelize
+    end
+    
+    def self.to_file_path class_name
+      class_name.sub(/^::/, '').underscore
+    end
+  end
+end

data/lib/class_loader/support.rb

@@ -0,0 +1,37 @@
+class String
+  unless "".respond_to? :underscore
+    def underscore
+      word = self.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+  end
+  
+  unless "".respond_to? :camelize
+    def camelize first_letter_in_uppercase = true
+      if first_letter_in_uppercase
+        gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      else
+        self[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+      end
+    end
+  end
+end
+
+class Module
+  unless respond_to? :namespace_for
+    def self.namespace_for class_name
+      list = class_name.split("::")
+      if list.size > 1
+        list.pop
+        return eval(list.join("::"), TOPLEVEL_BINDING, __FILE__, __LINE__)
+      else
+        return nil
+      end
+    end
+  end
+end

data/readme.md

@@ -0,0 +1,45 @@
+# ClassLoader automatically finds and loads classes 
+
+## 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.
+
+Let's say your application has the following structure
+
+	/your_app
+		/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
+
+	require 'class_loader'
+	autoload_dir '/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'	
+	
+**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.
+
+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) 2010 Alexey Petrushin http://bos-tec.com, released under the MIT license.

data/spec/class_loader_spec.rb

@@ -0,0 +1,139 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+require "class_loader"
+
+describe ClassLoader do  
+  before :all do
+    @dir = prepare_spec_data __FILE__
+  end
+  
+  after :all do
+    clean_spec_data __FILE__
+
+    remove_constants %w(
+      BasicSpec
+      OnlyOnceSpec
+      NamespaceTypeResolving NamespaceIsAlreadyDefinedAsClass
+      InvalidInfinityLoopClassName
+      AnonymousSpec
+      AnotherNamespace
+      ClassReloadingSpec
+      UnloadOldClass
+      PreloadingSpec
+      UnderscoredNamespace
+    )        
+  end
+  
+  after :each do
+    ClassLoader.clear
+  end
+  
+  it "should load classes from class path" do
+    autoload_dir "#{@dir}/basic"
+    
+    BasicSpec
+    BasicSpec::SomeNamespace::SomeClass
+  end
+    
+  it "should load classes only once" do
+    autoload_dir "#{@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 "#{@dir}/namespace_type_resolving"
+    
+    NamespaceTypeResolving.class.should == Class
+    NamespaceTypeResolving::SomeClass
+    
+    class NamespaceIsAlreadyDefinedAsClass; end    
+    NamespaceIsAlreadyDefinedAsClass::SomeClass
+  end
+  
+  it "should recognize infinity loop" do
+    autoload_dir "#{@dir}/infinity_loop"
+    
+    lambda{InfinityLoop}.should raise_error(/Class Name .+ doesn't correspond to File Name/)
+  end
+  
+  it "should correctly works inside of anonymous class" do
+    autoload_dir "#{@dir}/anonymous_class"
+    
+    module ::AnonymousSpec
+      class << self
+        def anonymous
+          ClassInsideOfAnonymousClass
+        end
+      end
+    end
+    
+    AnonymousSpec.anonymous
+  end
+  
+  it "should raise exception if class defined in another namespace" do
+    autoload_dir "#{@dir}/another_namespace"
+    
+    AnotherNamespace::NamespaceA
+    ClassLoader.error_on_defined_constant = true
+    lambda{
+      AnotherNamespace::NamespaceB
+    }.should raise_error(/Class '.+' is not defined in the '.+' Namespace!/)
+  end
+  
+  describe "reloading" do  
+    it "should reload class files" do
+      spec_dir = "#{@dir}/class_reloading"
+      fname = "#{spec_dir}/ClassReloadingSpec.rb"
+      autoload_dir spec_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
+class ClassReloadingSpec
+  def self.check; :another_value end
+end
+RUBY
+
+      File.open(fname, 'w'){|f| f.write code}
+    
+      ClassLoader.reload_class(ClassReloadingSpec.name)
+      ClassReloadingSpec.check.should == :another_value
+    end
+  
+    it "should unload old classes before reloading" do
+      autoload_dir "#{@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 "#{@dir}/preloading"
+    Object.const_defined?(:PreloadingSpec).should be_false    
+    ClassLoader.preload!
+    Object.const_defined?(:PreloadingSpec).should be_true
+  end  
+  
+  it "underscored smoke test" do
+    autoload_dir "#{@dir}/underscored"
+    
+    UnderscoredNamespace::UnderscoredClass
+  end
+end

data/spec/class_loader_spec_data/anonymous_class/AnonymousSpec/ClassInsideOfAnonymousClass.rb

@@ -0,0 +1,2 @@
+class ClassInsideOfAnonymousClass
+end

data/spec/class_loader_spec_data/another_namespace/AnotherNamespace/NamespaceA.rb

@@ -0,0 +1,2 @@
+class NamespaceA
+end

data/spec/class_loader_spec_data/another_namespace/AnotherNamespace/NamespaceB.rb

@@ -0,0 +1,5 @@
+class NamespaceB
+  class InnerClass; end
+
+  InnerClass::NamespaceA
+end

data/spec/class_loader_spec_data/basic/BasicSpec.rb

@@ -0,0 +1,2 @@
+class BasicSpec
+end

data/spec/class_loader_spec_data/basic/BasicSpec/SomeNamespace/SomeClass.rb

@@ -0,0 +1,2 @@
+class SomeClass
+end

data/spec/class_loader_spec_data/infinity_loop/InfinityLoop.rb

@@ -0,0 +1,2 @@
+class InvalidInfinityLoopClassName
+end

data/spec/class_loader_spec_data/namespace_type_resolving/NamespaceIsAlreadyDefinedAsClass/SomeClass.rb

@@ -0,0 +1,2 @@
+class SomeClass
+end

data/spec/class_loader_spec_data/namespace_type_resolving/NamespaceTypeResolving.rb

@@ -0,0 +1,2 @@
+class NamespaceTypeResolving
+end

data/spec/class_loader_spec_data/namespace_type_resolving/NamespaceTypeResolving/SomeClass.rb

@@ -0,0 +1,2 @@
+class SomeClass
+end

data/spec/class_loader_spec_data/only_once/OnlyOnceSpec.rb

@@ -0,0 +1,2 @@
+class OnlyOnceSpec
+end

data/spec/class_loader_spec_data/preloading/PreloadingSpec.rb

@@ -0,0 +1,2 @@
+class PreloadingSpec
+end

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

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

data/spec/class_loader_spec_data/unload_old_class/UnloadOldClass.rb

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

data/spec/file_system_adapter_spec.rb

@@ -0,0 +1,91 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+require "class_loader/file_system_adapter/camel_case_translator"
+require "class_loader/file_system_adapter"
+require "class_loader/chained_adapter"
+
+describe ClassLoader::FileSystemAdapter do  
+  before :all do
+    @dir = prepare_spec_data __FILE__
+  end
+  
+  before :each do        
+    @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 "#{@dir}/common"    
+  end
+  
+  after :all do
+    clean_spec_data __FILE__
+  end
+  
+  def write_file path, klass
+    File.open("#{@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::NonExistingClass").should be_false
+  end
+  
+  it "should works with multiple class paths" do
+    @adapter.add_path "#{@dir}/multiple_class_paths/path_a"
+    @adapter.add_path "#{@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" 
+  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("#{@dir}/non_existing_path").should be_nil
+    @adapter.to_class_name("#{@dir}/common/SomeNamespace").should == "SomeNamespace"
+    @adapter.to_class_name("#{@dir}/common/SomeNamespace/SomeClass").should == "SomeNamespace::SomeClass"
+  end
+  
+  it "shouldn't allow to add path twice" do
+    @adapter.clear
+    @adapter.add_path "#{@dir}/common"
+    lambda{@adapter.add_path "#{@dir}/common"}.should raise_error(/already added/)
+  end
+  
+  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 "#{@dir}/search_only_watched", false
+      changed_classes.should == []        
+      
+      sleep(1) && write_file("watching/SomeClass.rb", "SomeClass")
+      changed_classes.should == []
+    end
+      
+    it "each_changed_class" do
+      @adapter.add_path "#{@dir}/watching", true
+      
+      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
+end

data/spec/file_system_adapter_spec_data/common/SomeNamespace/SomeClass.rb

@@ -0,0 +1 @@
+class SomeClass; end

data/spec/file_system_adapter_spec_data/multiple_class_paths/path_a/ClassInPathA.rb

@@ -0,0 +1,2 @@
+class ClassInPathA
+end

data/spec/file_system_adapter_spec_data/multiple_class_paths/path_b/ClassInPathB.rb

@@ -0,0 +1,2 @@
+class ClassInPathB
+end

data/spec/helper.rb

@@ -0,0 +1,22 @@
+require 'spec'
+require 'fileutils'
+
+def prepare_spec_data spec_file_name
+  dir = File.expand_path(spec_file_name.sub(/\.rb$/, ''))
+  original_data_dir = dir + "_data"
+    
+  FileUtils.rm_r dir if File.exist? dir
+  FileUtils.cp_r original_data_dir, dir
+    
+  dir
+end
+
+def clean_spec_data spec_file_name
+  dir = spec_file_name.sub(/\.rb$/, '')
+  FileUtils.rm_r dir if File.exist? dir
+end
+
+def remove_constants *args
+  args = args.first if args.size == 1 and args.first.is_a?(Array)
+  args.each{|c| Object.send :remove_const, c if Object.const_defined? c}       
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--reverse

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: class-loader
+version: !ruby/object:Gem::Version 
+  hash: 17
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 1
+  version: 0.3.1
+platform: ruby
+authors: 
+- Alexey Petrushin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-10 00:00:00 +04:00
+default_executable: 
+dependencies: []
+
+description: Makes any directory looks like Ruby Gem
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- readme.md
+- lib/class_loader/chained_adapter.rb
+- lib/class_loader/class_loader.rb
+- 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/support.rb
+- lib/class_loader.rb
+- spec/class_loader_spec.rb
+- spec/class_loader_spec_data/anonymous_class/AnonymousSpec/ClassInsideOfAnonymousClass.rb
+- spec/class_loader_spec_data/another_namespace/AnotherNamespace/NamespaceA.rb
+- spec/class_loader_spec_data/another_namespace/AnotherNamespace/NamespaceB.rb
+- spec/class_loader_spec_data/basic/BasicSpec/SomeNamespace/SomeClass.rb
+- spec/class_loader_spec_data/basic/BasicSpec.rb
+- spec/class_loader_spec_data/infinity_loop/InfinityLoop.rb
+- spec/class_loader_spec_data/namespace_type_resolving/NamespaceIsAlreadyDefinedAsClass/SomeClass.rb
+- spec/class_loader_spec_data/namespace_type_resolving/NamespaceTypeResolving/SomeClass.rb
+- spec/class_loader_spec_data/namespace_type_resolving/NamespaceTypeResolving.rb
+- spec/class_loader_spec_data/only_once/OnlyOnceSpec.rb
+- spec/class_loader_spec_data/preloading/PreloadingSpec.rb
+- spec/class_loader_spec_data/underscored/underscored_namespace/underscored_class.rb
+- spec/class_loader_spec_data/unload_old_class/UnloadOldClass.rb
+- spec/file_system_adapter_spec.rb
+- spec/file_system_adapter_spec_data/common/SomeNamespace/SomeClass.rb
+- spec/file_system_adapter_spec_data/multiple_class_paths/path_a/ClassInPathA.rb
+- spec/file_system_adapter_spec_data/multiple_class_paths/path_b/ClassInPathB.rb
+- spec/helper.rb
+- spec/spec.opts
+has_rdoc: true
+homepage: http://github.com/alexeypetrushin/class-loader
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Makes any directory looks like Ruby Gem
+test_files: []
+