class_loader 0.4.15 → 3.0.0

data/Rakefile

@@ -3,7 +3,8 @@ require 'rake_ext'
 project(
   name: "class_loader",
   gem: true,
-  summary: "Automatically finds, loads and reloads classes",
+  summary: "Automatically find, load and reload classes",
+  version: '3.0.0',
 
   author: "Alexey Petrushin",
   homepage: "http://github.com/alexeypetrushin/class_loader"

data/lib/class_loader/class_loader.rb

@@ -1,210 +1,123 @@
-require 'monitor'
-
-warn 'ClassLoader: working in slow, debug mode with explicit tmp file generation!' if defined?(CLASS_LOADER_GENERATE_TMP_FILES)
+require 'class_loader/support'
 
 module ClassLoader
-  @observers = []
-  SYNC = Monitor.new
-
+  @loaded_classes = {}
   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
-
-        class_name = namespace ? "#{namespace.name}::#{const}" : const
-        simple_also_tried = false
-        begin
-          simple_also_tried = (namespace == nil)
-
-          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
+    attr_reader :loaded_classes
 
-            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
-
-            result = namespace ? namespace.const_get(const) : Object.const_get(const)
+    # Hierarchically searching for class file, according to modules hierarchy.
+    #
+    # For example, let's suppose that `C` class defined in '/lib/a/c.rb' file, and we referencing it
+    # in the `A::B` namespace, like this - `A::B::C`, the following files will be checked:
+    #
+    # - '/lib/a/b/c.rb' - there's nothing, moving up in hierarchy.
+    # - '/lib/a/c.rb' - got and load it.
+    def load namespace, const
+      original_namespace = namespace
+      namespace = nil if namespace == Object or namespace == Module
+      target_namespace = namespace
+
+      # Need this hack to work with anonymous classes.
+      namespace = eval "#{name_hack(namespace)}" if namespace
+
+      # Hierarchically searching for class name.
+      begin
+        class_name = namespace ? "#{namespace.name}::#{const}" : const.to_s
+        class_file_name = get_file_name class_name
+
+        # Trying to load class file, if its exist.
+        loaded = begin
+          require class_file_name
+          true
+        rescue LoadError => e
+          # Not the best way - hardcoding error messages, but it's the fastest way
+          # to check existence of file & load it.
+          raise e unless e.message =~ /no such file.*#{Regexp.escape(class_file_name)}/
+          false
+        end
 
-            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
+        if loaded
+          # Checking that class hasn't been loaded previously, sometimes it may be caused by
+          # weird class definition code.
+          if loaded_classes.include? class_name
+            raise_without_self NameError, \
+              "something wrong with '#{const}' referenced from '#{original_namespace}' scope!"
           end
-        end until simple_also_tried
-
-        return false
-      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}::/, "")
+          # Checking that class defined in correct namespace, not the another one.
+          unless namespace ? namespace.const_defined?(const, false) : Object.const_defined?(const, false)
+            raise_without_self NameError, \
+              "class name '#{class_name}' doesn't correspond to file name '#{class_file_name}'!"
+          end
 
-        # removing old class
-        # class_container = (namespace || Object)
-        # class_container.send :remove_const, name if class_container.const_defined? name
+          # Getting the class itself.
+          klass = namespace ? namespace.const_get(const, false) : Object.const_get(const, false)
 
-        return load_class namespace, name, true
-      end
-    end
+          loaded_classes[class_name] = klass
 
-    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")]
+          return klass
         end
-      end
-      begining = nesting.collect{|l, t| "#{t} #{l};"}.join(' ')
-      ending = nesting.collect{"end"}.join('; ')
-      return "#{begining}#{script} \n#{ending}"
-    end
-
-
-    #
-    # Utilities
-    #
-    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_path 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
-    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_class_loader, :const_missing
-        protected :const_missing_without_class_loader
-        def const_missing const
-         if klass = ClassLoader.load_class(self, const.to_s)
-            klass
-          else
-            const_missing_without_class_loader const
-          end
-        end
-      end
-      @hooked = true
-    end
+        # Moving to higher namespace.
+        global_also_tried = namespace == nil
+        namespace = Module.namespace_for namespace.name if namespace
+      end until global_also_tried
 
-    attr_writer :adapter
-    def adapter
-      @adapter ||= default_adapter
+      return nil
     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
-          while true
-            sleep(watch_interval || 2)
-            adapter.each_changed_class do |class_name|
-              puts "reloading #{class_name}"
-              reload_class class_name
-            end
-          end
-        end
+    # Dynamic class loading is not thread safe (known Ruby bug), to workaround it
+    # You can forcefully preload all Your classes in production when Your app starts.
+    def preload path
+      Dir.glob("#{path}/**/*.rb").each do |class_path|
+        class_file_name = class_path.sub("#{path}/", '').sub(/\.rb$/, '')
+        require class_file_name
       end
     end
 
-    def stop_watching!
-      if @watching_thread
-        @watching_thread.kill
-        @watching_thread = nil
-      end
+    # Watch and reload files.
+    def watch path
+      watcher.paths << path
+      watcher.start
     end
 
-    def preload!
-      adapter.each_class do |class_name|
-        reload_class class_name
-      end
+    def watcher
+      require 'class_loader/watcher'
+      @watcher ||= ClassLoader::Watcher.new
     end
 
-
     protected
-      def default_adapter
-        adapter = ChainedAdapter.new
-        adapter.adapters << FileSystemAdapter.new(UnderscoredTranslator)
-        adapter.adapters << FileSystemAdapter.new(CamelCaseTranslator)
-        adapter
-      end
-
-      def load class_name, const
-        script = adapter.read class_name
-        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
-          if file_path =~ /\.rb$/
-            tmp_file_path = file_path.sub /\.rb$/, '.cltmp.rb'
-            begin
-              File.open(tmp_file_path, "w"){|f| f.write(script)}
-              Kernel.load tmp_file_path
-            ensure
-              File.delete tmp_file_path if defined?(CLASS_LOADER_CLEAN) and ::File.exist?(tmp_file_path)
-            end
-          else
-            eval script, TOPLEVEL_BINDING, file_path
-          end
-        end
-      end
-
-      def raise_without_self exception, message
-        raise exception, message, caller.select{|path| path !~ /\/lib\/class_loader\// and path !~ /monitor\.rb/}
+      # Use this method to define class name to file name mapping, by default it uses underscored paths,
+      # but You can override this method to use camel case for example.
+      def get_file_name class_name
+        class_name.underscore
       end
 
+      # 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>"
+      #
       def name_hack namespace
         if namespace
           result = namespace.to_s.gsub("#<Class:", "").gsub(">", "")
@@ -212,31 +125,10 @@ module ClassLoader
         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
+
+      def raise_without_self exception, message
+        raise exception, message, caller.select{|path| path !~ /\/lib\/class_loader\//}
       end
   end
 end

data/lib/class_loader/support.rb

@@ -10,21 +10,10 @@ class String
       word
     end
   end
-
-  unless method_defined? :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
-    # TODO3 cache it?
     def self.namespace_for class_name
       list = class_name.split("::")
       if list.size > 1

data/lib/class_loader/watcher.rb

@@ -0,0 +1,44 @@
+class ClassLoader::Watcher
+  attr_accessor :paths, :interval
+
+  def initialize
+    @paths, @files = [], {}
+    @interval = 2
+  end
+
+  def stop
+    return unless thread
+    thread.kill
+    @thread = nil
+  end
+
+  def start
+    return if thread
+    @thread = Thread.new do
+      while true
+        sleep interval
+        check
+      end
+    end
+  end
+
+  def check
+    paths.each do |path|
+      Dir.glob("#{path}/**/*.rb").each do |class_path|
+        updated_at = File.mtime class_path
+        if last_updated_at = files[class_path]
+          if last_updated_at < updated_at
+            class_file_name = class_path.sub "#{path}/", ''
+            warn "reloading #{class_file_name}"
+            load class_file_name
+          end
+        else
+          files[class_path] = updated_at
+        end
+      end
+    end
+  end
+
+  protected
+    attr_reader :files, :thread
+end

data/lib/class_loader.rb

@@ -1,21 +1,8 @@
-raise 'ruby 1.9.2 or higher required!' if RUBY_VERSION < '1.9.2'
+autoload :ClassLoader, 'class_loader/class_loader'
 
-module ClassLoader
-end
-
-%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_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
+class Module
+  alias_method :const_missing_without_autoload, :const_missing
+  def const_missing const
+    ClassLoader.load(self, const) || const_missing_without_autoload(const)
+  end
 end

data/readme.md

@@ -1,40 +1,39 @@
-# Automatically finds and loads classes for Your Ruby App
+# Automatically find, load and reload classes
 
-## Overview
-There's only one method - :autoload_path, kind of turbocharged :autoload, it understands namespaces, figure out dependencies and can watch and reload changed files.
+Suppose there's following directory structure:
 
-Let's say Your application has the following structure
+    /lib
+      /some_class.rb        # class SomeClass; end
+      /some_namespace
+        /another_class.rb   # class SomeNamespace:AnotherClass; end
+      /some_namespace.rb    # module SomeNamespace; end
 
-	/your_app
-		/lib
-			/animals
-				/dog.rb
-			/zoo.rb
+All these classes will be loaded automatically, on demand:
 
-Just point ClassLoader to the directory(ies) Your classes are located and it will find and load them automatically
+``` ruby
+require 'class_loader'
 
-	require 'class_loader'
-	autoload_path '/your_app/lib'
+SomeClass
+SomeNamespace::AnotherClass
+```
 
-	Zoo.add Animals::Dog.new # <= all classes loaded automatically
+No need for require:
 
-no need for
+``` ruby
+require 'some_class'
+require 'some_namespace'
+require 'some_namespace/another_class'
+```
 
-	# require 'animals/dog'
-	# require 'app'
+or autoload:
 
-you can specify multiple autoload directories, and tell it to watch them
-
-	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.
-
-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?
+``` ruby
+autoload :SomeClass,      'some_class'
+autoload :SomeNamespace,  'some_namespace'
+module SomeNamespace
+  autoload :AnotherClass, 'some_namespace/another_class'
+end
+```
 
 ## Installation