fakefs-require 0.1.1

data/.gitignore

@@ -0,0 +1,3 @@
+/.loadpath
+/.project
+/test.rb

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Lars Gierth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,92 @@
+Faked #require and #autoload
+============================
+
+Testing a library that loads ruby source files by configuration, I noticed that
+defunkt's great FakeFS was lacking support for faking #require, #autoload, etc.
+
+
+Installation
+------------
+
+    $ gem install fakefs-require
+
+
+Usage
+-----
+
+    require "fakefs/require"
+    FakeFS::Require.activate!
+    
+    File.open "foo.rb", "w" {|f| f.write "puts 'hello world!'" }
+    require "foo"
+
+
+Gems, Standard Lib and Load Path
+--------------------------------
+
+FakeFS::Require provides a fallback for tests which use code (most likely gems)
+that #require source files or gems at runtime (e.g. Usher). This will fail
+because the required files don't exist in FakeFS. You can workaround this issue
+by activating like this:
+
+    FakeFS::Require.activate! :fallback => true
+
+This will make the faked #require call the original #require if loading the
+passed file in FakeFS fails.
+
+FakeFS::Require uses $LOAD_PATH to find out in which paths to search (just like
+the original...).
+
+
+Autoloading
+-----------
+
+The autoloading mechanism ignores a monkey patched #require (see
+http://blade.nagaokaut.ac.jp/cgi-bin/vframe.rb/ruby/ruby-core/20190?20046-21072+split-mode-vertical),
+so we will have to fake #autoload itself to get this working. If you use gems or
+other code that utilizes #autoload (e.g. Rack), pass the :autoload flag to
+::activate!.
+
+    FakeFS::Require.activate! :autoload => true
+
+Note: This will only work for autoload calls made _after_ ::activate! has been
+called.
+
+
+Limitations
+-----------
+
+There are two known limitations to FakeFS::Require (besides ones to FakeFS).
+
+1.  David Masover points this out:
+        
+        irb(main):001:0> autoload :CSV, 'csv'
+        => nil
+        irb(main):002:0> module CSV
+        irb(main):003:1> end
+        TypeError: CSV is not a module
+                from (irb):2
+    
+    See http://www.ruby-forum.com/topic/205612#898211 for more information on
+    this.
+
+2.  If a class/module that calls #autoload defines #const_missing the faked
+    autoload won't work. Maybe this is a WONTFIX, I don't know... any ideas?
+
+
+Contributing
+------------
+
+Once you've made your great commits:
+
+1. Fork fakefs-require
+2. Create a topic branch - `git checkout -b my_branch`
+3. Push to your branch - `git push origin my_branch`
+4. Create an issue with a link to your branch
+5. That's it!
+
+
+License
+-------
+
+fakefs-require is subject to the MIT License (see LICENSE file)

data/Rakefile

@@ -0,0 +1,29 @@
+require "rake/testtask"
+
+task :default => [:test]
+
+Rake::TestTask.new :test do |t|
+  t.libs = ["lib"]
+  t.test_files = FileList["test/*_test.rb"]
+  t.ruby_opts << "-rubygems"
+  t.ruby_opts << "-rtest/unit"
+  t.ruby_opts << "-rtest/helper"
+end
+
+begin
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name        = "fakefs-require"
+    gemspec.summary     = "Faked #require and #autoload for defunkt's FakeFS"
+    gemspec.email       = "lars.gierth@altefeuerwachekoeln.de"
+    gemspec.homepage    = "http://github.com/lgierth/fakefs-require"
+    gemspec.description = "Faked #require and #autoload for defunkt's FakeFS"
+    gemspec.authors     = ["Lars Gierth"]
+    gemspec.has_rdoc    = false
+    gemspec.add_dependency "fakefs"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/fakefs/require.rb

@@ -0,0 +1,158 @@
+module FakeFS
+  
+  # TODO write documentation
+  module Require
+    @active = false
+    
+    def self.activate! opts = {}
+      unless @active
+        Kernel.class_eval do
+          alias_method :fakefs_original_require, :require
+          alias_method :require, :fakefs_require
+        end
+        @active = true
+        
+        @opts = {
+          :fallback => false,
+          :autoload => false,
+        }
+        @opts.merge!(opts)
+        @identity_map = []
+        
+        Module.class_eval do
+          alias_method :fakefs_original_autoload, :autoload
+          alias_method :autoload, :fakefs_autoload
+          
+          alias_method :fakefs_original_autoload?, :autoload?
+          alias_method :autoload?, :fakefs_autoload?
+          
+          alias_method :fakefs_original_const_missing, :const_missing
+          alias_method :const_missing, :fakefs_const_missing
+        end if @opts[:autoload]
+      end
+    end
+    
+    def self.deactivate!
+      if @active
+        Kernel.class_eval do
+          alias_method :require, :fakefs_original_require
+        end
+        @active = false
+        
+        Module.class_eval do
+          alias_method :autoload, :fakefs_original_autoload
+          alias_method :autoload?, :fakefs_original_autoload?
+          alias_method :const_missing, :fakefs_original_const_missing
+        end if @opts[:autoload]
+      end
+    end
+    
+    def self.active?
+      @active
+    end
+    
+    def self.clear
+      @identity_map = []
+      @autoloadable = {}
+      @autoloaded = {}
+    end
+    
+    def self.opts
+      @opts
+    end
+    
+    def self.identity_map
+      @identity_map
+    end
+    
+    def self.autoloadable
+      @autoloadable ||= {}
+    end
+    
+    def self.autoloaded
+      @autoloaded ||= {}
+    end
+    
+    # TODO fix identity map behaviour
+    def fakefs_require fn
+      begin
+        orig_fn = fn.dup
+        fn = fn + ".rb" unless fn[-3..-1] == ".rb"
+        
+        path = nil
+        2.times do
+          if fn.match "^/"
+            path = fn if File.exist? fn
+          else
+            $LOAD_PATH.each do |p|
+              if File.exist? p + "/" + fn
+                path = p + "/" + fn
+                break
+              end
+            end
+          end
+          
+          break if path or orig_fn[-3..-1] == ".rb" or fn[-3..-1] != ".rb"
+          fn = fn[0..-3]
+        end
+        
+        raise LoadError, "no such file to load -- " + orig_fn unless path
+      rescue LoadError => load_error
+        if FakeFS::Require.opts[:fallback]
+          opts = FakeFS::Require.opts
+          begin
+            FakeFS.deactivate!
+            FakeFS::Require.deactivate!
+            return fakefs_original_require orig_fn
+          ensure
+            FakeFS::Require.activate! opts
+            FakeFS.activate!
+          end
+        end
+        raise load_error
+      end
+      
+      return false if FakeFS::Require.identity_map.include? path
+      
+      FakeFS::Require.identity_map << path
+      File.open path, "r" do |f|
+        Object.class_eval f.read, fn, 1
+      end      
+      return true
+    end
+    
+    module Autoload
+      def fakefs_autoload const, file
+        Require.autoloadable[self] ||= {}
+        Require.autoloadable[self][const] = file
+      end
+      
+      def fakefs_autoload? const
+        hsh = Require.autoloadable[self]
+        return hsh[const] if hsh
+      end
+      
+      def fakefs_const_missing name
+        Require.autoloaded[self] ||= {}
+        file = autoload? name
+        if file and !Require.autoloaded[self][name]
+          Require.autoloaded[self][name] = true
+          require file
+          return const_get name if const_defined? name
+        end
+        parent = (self == Object) ? "" : self.to_s + "::"
+        raise NameError, "uninitialized constant #{parent}" + name.to_s, caller
+      end
+    end
+    
+  end
+  
+end
+
+module Kernel
+  include FakeFS::Require
+end
+
+class Module
+  include FakeFS::Require::Autoload
+end

data/test/helper.rb

@@ -0,0 +1,2 @@
+require "fakefs/safe"
+require "fakefs/require"

data/test/require_test.rb

@@ -0,0 +1,175 @@
+class RequireTest < Test::Unit::TestCase
+
+  def setup
+    FakeFS.activate!
+  end
+
+  def teardown
+    FakeFS::FileSystem.clear
+    FakeFS.deactivate!
+  end
+  
+  def test_fakes_require
+    FakeFS::Require.activate!
+    
+    # require a file
+    code = <<-EOS
+      module FakeFSTestRequire1
+      end
+    EOS
+    File.open "fake_fs_test_require1.rb", "w" do |f|
+      f.write code
+    end
+    require "fake_fs_test_require1.rb"
+    assert ::FakeFSTestRequire1
+    
+    # require a file that doesn't exist
+    assert_raise LoadError do
+      require "foo"
+    end
+    
+    # automatically append .rb
+    code = <<-EOS
+      module FakeFSTestRequire2
+      end
+    EOS
+    File.open "fake_fs_test_require2.rb", "w" do |f|
+      f.write code
+    end
+    require "fake_fs_test_require2"
+    assert ::FakeFSTestRequire2
+    
+    # foo.rb has higher priority than foo
+    code = <<-EOS
+      module FakeFSTestRequire3_WithDotRb
+      end
+    EOS
+    File.open "fake_fs_test_require3.rb", "w" do |f|
+      f.write code
+    end
+    code = <<-EOS
+      module FakeFSTestRequire3_WithoutDotRb
+      end
+    EOS
+    File.open "fake_fs_test_require3", "w" do |f|
+      f.write code
+    end
+    require "fake_fs_test_require3"
+    assert ::FakeFSTestRequire3_WithDotRb
+    
+    # don't require files twice
+    code = <<-EOS
+      module FakeFSTestRequire4
+      end
+    EOS
+    File.open "fake_fs_test_require4.rb", "w" do |f|
+      f.write code
+    end
+    assert require("fake_fs_test_require4")
+    assert !require("fake_fs_test_require4")
+    FakeFS::Require.clear
+    assert require("fake_fs_test_require4")
+    
+    # properly deactivate
+    FakeFS::Require.deactivate!
+    assert_raise LoadError do
+      require "bar"
+    end
+    
+    FakeFS::Require.clear
+  end
+  
+  def test_fakes_require_with_fallback
+    FakeFS.deactivate!
+    require "tmpdir"
+    FakeFS.activate!
+    
+    FakeFS::Require.activate! :fallback => true
+    
+    # load a file that's in the real (= non-faked) load path
+    begin
+      dir = RealDir.tmpdir + "/" + rand.to_s[2..-1]
+      RealDir.mkdir dir
+      
+      $LOAD_PATH.unshift dir
+      
+      code = <<-EOS
+        module FakeFSTestRequireWithFallback
+        end
+      EOS
+      RealFile.open dir + "/fake_fs_test_require_with_fallback.rb", "w" do |f|
+        f.write code
+      end
+      
+      require "fake_fs_test_require_with_fallback.rb"
+      assert FakeFSTestRequireWithFallback
+    ensure
+      RealFile.delete dir + "/fake_fs_test_require_with_fallback.rb"
+      RealDir.delete dir
+      $LOAD_PATH.delete dir
+    end
+    
+    # load a file that exists neither in fakefs nor in the real load path
+    assert_raise LoadError do
+      require "fake_fs_test_require_with_fooback.rb"
+    end
+    
+    # load a file from a gem
+    require "rack/static.rb"
+    assert ::Rack::Static
+    assert_raise LoadError do
+      require "rack/is_great"
+    end
+    
+    # turned off fallback
+    FakeFS::Require.opts[:fallback] = false
+    assert_raise LoadError do
+      require "rack/mime"
+    end
+    
+    FakeFS::Require.deactivate!
+    FakeFS::Require.clear
+  end
+  
+  def test_fakes_autoload
+    FakeFS::Require.activate! :autoload => true
+    
+    code = <<-EOS
+      module FakeFSTestAutoload
+        autoload :Foo, "fake_fs_test_autoload/foo"
+        autoload :Bar, "fake_fs_test_autoload/bar"
+      end
+    EOS
+    File.open "fake_fs_test_autoload.rb", "w" do |f|
+      f.write code
+    end
+    code = <<-EOS
+      module FakeFSTestAutoload
+        module Foo
+        end
+      end
+    EOS
+    File.open "fake_fs_test_autoload/foo.rb", "w" do |f|
+      f.write code
+    end
+    
+    require "fake_fs_test_autoload"
+    
+    # autoload
+    assert FakeFSTestAutoload::Foo
+    
+    # autoload with non-existing path
+    assert_raise LoadError do
+      FakeFSTestAutoload::Bar
+    end
+    
+    # no autoload
+    assert_raise NameError do
+      FakeFSTestAutoload::Baz
+    end
+    
+    FakeFS::Require.deactivate!
+    FakeFS::Require.clear
+  end
+
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: fakefs-require
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Lars Gierth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-20 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: fakefs
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: "Faked #require and #autoload for defunkt's FakeFS"
+email: lars.gierth@altefeuerwachekoeln.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- lib/fakefs/require.rb
+- test/helper.rb
+- test/require_test.rb
+has_rdoc: true
+homepage: http://github.com/lgierth/fakefs-require
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: "Faked #require and #autoload for defunkt's FakeFS"
+test_files: 
+- test/helper.rb
+- test/require_test.rb