filesystem 0.1.0

data/lib/filesystem.rb

@@ -0,0 +1,351 @@
+# FileSystem is a test-obsessed library for mocking out the entire file system.
+# It provides mock objects that clone the functionality of File, FileUtils, 
+# Dir, and other in-Ruby file-access libraries.
+# 
+# To use FileSystem in your production code, call FileSystem.get_[ class ].
+#
+#   FileSystem.get_file               => File
+#   FileSystem.get_file_utils         => FileUtils
+#   FileSystem.get_dir                => Dir
+#   FileSystem.get_dir.entries( '.' ) => [".", "..", ...]
+#
+# Then, to turn these into mock instances for a test case, simply call
+#
+#   FileSystem.mock = true
+#
+# When you've done this, the normal calls will actually return adapters that
+# pretend to be the class in question:
+#
+#   FileSystem.get_file               => FileSystem::FileAdapter
+#   FileSystem.get_file_utils         => FileSystem::FileUtilsAdapter
+#   FileSystem.get_dir                => FileSystem::DirAdapter
+#   FileSystem.get_dir.entries( '.' ) => [".", "..", ...]
+#
+# You can get direct access to the enclosed MockFileSystem by calling 
+# FileSystem.mock_file_system.
+#
+# You can view the Rubyforge project page at
+# http://rubyforge.org/projects/filesystem.
+
+require 'delegate'
+require 'extensions/all'
+require 'fileutils'
+require 'singleton'
+
+module FileSystem
+	Version = '0.1.0'
+
+	@@mock = false
+	
+	def self.method_missing( symbol, *args ) #:nodoc:
+		class_name = nil
+		if symbol.id2name =~ /^get_(.*)/
+			class_name = $1.capitalize
+			class_name.gsub!( /_(\w)/ ) { |s| $1.capitalize }
+			unless %w( Dir File FileUtils ).include?( class_name )
+				class_name = nil
+			end
+		end
+		if class_name
+			if @@mock
+				return_class = Class.by_name( 'FileSystem::' + class_name + 'Adapter' )
+			else
+				return_class = Class.by_name( class_name )
+			end
+			return_class || super
+		elsif @@mock
+			mock_file_system.send( symbol, *args )
+		else
+			super
+		end
+	end
+	
+	# Tell FileSystem whether to offer interfaces to the real or mock file system.
+	# +is_mock+ should be a Boolean.
+	def self.mock= ( is_mock ); @@mock = is_mock; end
+	
+	# If we're in mock mode, this will return the MockFileSystem; otherwise it
+	# will raise a RuntimeError.
+	def self.mock_file_system
+		@@mock ? MockFileSystem.instance : ( raise RuntimeError )
+	end
+	
+	module Adapter #:nodoc:
+		@@delegated_methods = [ :delete, :entries, :mtime ]
+	
+		def get_node( nodename ); MockFileSystem.instance.get_node( nodename ); end
+		
+		def method_missing( sym, *args )
+			if @@delegated_methods.include?( sym )
+				get_node( args.first ).send( sym )
+			else
+				super
+			end
+		end
+
+		def respond_to?( sym )
+			@@delegated_methods.include?( sym ) ? true : super
+		end
+	end
+	
+	class DirAdapter #:nodoc:
+		extend Adapter
+		include Adapter
+		
+		def self.mkdir( dirname )
+			path = Path.new( dirname ).absolute
+			get_node( path.parent ).mkdir( path.node )
+		end
+		
+		def initialize( dirname )
+			unless get_node( dirname ).class == MockFileSystem::MockDir
+				raise Errno::ENOTDIR 
+			end
+		end
+	end
+	
+	class FileAdapter #:nodoc:
+		extend Adapter
+	
+		def self.chmod( perms, *filenames )
+			get_node( filenames.first ).permissions = perms
+		end
+		
+		class << self
+			def exist?( filename )
+				begin
+					get_node( filename )
+					true
+				rescue Errno::ENOENT
+					false
+				end
+			end
+			
+			alias_method :exists?, :exist?
+		end
+		
+		def self.open( fd, mode_string = File::RDONLY, &action )
+			if mode_string.class == String
+				if mode_string == 'w'
+					mode_string = File::WRONLY
+				end
+			end
+			if mode_string == File::RDONLY
+				node = get_node( fd )
+				if node && node.permissions && node.permissions[0] == 0
+					raise Errno::EACCES
+				end
+				result = action.call( node )
+				node.rewind
+				result
+			else
+				path = Path.new( fd ).absolute
+				dir = get_node( path.parent )
+				if ( mode_string & File::APPEND > 0 )
+					mock_file = get_node( fd )
+				else
+					mock_file = MockFileSystem::MockFile.new( dir, path.node, '' )
+				end
+				if ( mode_string & File::APPEND == File::APPEND )
+					mock_file.pos = mock_file.size
+				end
+				action.call( mock_file )
+				mock_file.rewind
+				if ( mode_string & File::APPEND == 0 )
+					dir[path.node] = mock_file
+				end
+			end
+		end
+	end
+	
+	class FileUtilsAdapter #:nodoc:
+		extend Adapter
+		
+		def self.cp( src, dest, options = {} )
+			file = get_node( src ).clone
+			dest_path = Path.new( dest ).absolute
+			dest_dir = get_node( dest_path.parent )
+			dest_dir[dest_path.node] = file
+			file.name = dest_path.node
+			file.parent = dest_dir
+		end
+		
+		def self.mv( src, dest, options = {} )
+			cp( src, dest, options )
+			FileSystem.get_file.delete( src )
+		end
+	
+		def self.touch( file )
+			begin
+				get_node( file ).mtime = Time.now
+			rescue Errno::ENOENT
+				path = Path.new( file ).absolute
+				parent_dir = get_node( path.parent )
+				file = MockFileSystem::MockFile.new( parent_dir, path.node, nil )
+				parent_dir[path.node] = file
+			end
+		end
+	end
+	
+	# The MockFileSystem is the singleton class that pretends to be the file system in mock mode. When it's first created, it fills in one path up to your real directory location; other paths will have to be filled by hand using +fill_path+.
+	class MockFileSystem
+		include Singleton
+		
+		# Flushes all file information out of the MockFileSystem.
+		def self.flush; instance.flush; end
+		
+		def initialize #:nodoc:
+			flush
+		end
+		
+		# Flushes all file information out of the MockFileSystem.
+		def flush; @root = MockRoot.new( '' ); fill_path( '.' ); end
+		
+		def get_node( dirname ) #:nodoc:
+			@root.get_node( dirname )
+		end
+		
+		# Use this method to fill in directory paths. This is the same as calling mkdir a bunch of times.
+		#
+		#   FileSystem.mock_file_system.fill_path '/usr/local/bin'
+		#   FileSystem.mock_file_system.fill_path '/home/francis/Desktop/myproject/'
+		def fill_path( dirname )
+			@root.fill_path( Path.new( dirname ).absolute.strip )
+		end
+		
+		module Node #:nodoc:
+			attr_accessor :mtime, :name, :parent, :permissions
+		end
+		
+		class MockDir < DelegateClass( Hash ) #:nodoc:
+			include Node
+			
+			def initialize( name, parent = nil )
+				super( {} )
+				@name, @parent = name, parent
+				@mtime = Time.now
+			end
+			
+			def []= ( name, child )
+				super
+				@mtime = child.mtime
+			end
+			
+			def delete( child = nil )
+				child ? super( child.name ) : parent.delete( self )
+			end
+			
+			def entries; %w( . .. ).concat( keys ); end
+			
+			def get_node( dirname )
+				if dirname.first == '..'
+					self.parent.get_node( dirname[1..-1] )
+				elsif dirname.first == '.'
+					self.get_node( dirname[1..-1] )
+				elsif dirname.size > 1
+					subdir = self[dirname.first]
+					subdir ? subdir.get_node( dirname[1..-1] ) : ( raise Errno::ENOENT )
+				elsif dirname == ''
+					self
+				else
+					self[dirname.strip] or ( raise Errno::ENOENT )
+				end
+			end
+			
+			def fill_dir( dirname )
+				dir = self[dirname]
+				if dir.nil?
+					dir = MockDir.new( dirname, self )
+					self[dirname] = dir
+					@mtime = dir.mtime
+				end
+				dir
+			end
+			
+			def fill_path( dirname )
+				if dirname.size > 1
+					dir = fill_dir( dirname.first )
+					dir.fill_path( dirname[1..-1] )
+				else
+					fill_dir( dirname )
+				end
+			end
+			
+			def mkdir( dirname ); fill_path( Path.new( dirname ) ); end
+		end
+		
+		class MockFile < DelegateClass( StringIO ) #:nodoc:
+			include Node
+			
+			attr_writer :contents
+		
+			def initialize( parent, name, contents )
+				@name = name; @parent = parent; @mtime = Time.now; @contents = contents
+				super( StringIO.new( contents ) ) if contents
+			end
+			
+			def clone
+				rewind
+				clone = self.class.new( @parent, @name, gets( nil ) )
+				clone.mtime = @mtime
+				clone
+			end
+
+			def delete; parent.delete( self ); end
+			
+			def gets( sep_string = $/ )
+				@contents ? super( sep_string ) : nil
+			end
+			
+			def rewind; @contents ? super : nil; end
+		end
+		
+		class MockRoot < MockDir #:nodoc:
+			def get_node( dirname )
+				begin
+					super( Path.new( dirname ).absolute.strip )
+				rescue Errno::ENOENT
+					raise Errno::ENOENT.new( dirname )
+				end
+			end
+		end
+	end
+	
+	class Path < String #:nodoc:
+		@@getwd = nil
+		
+		def self.getwd
+			@@getwd = Dir.getwd if @@getwd.nil?
+			@@getwd
+		end
+	
+		def []( *args ); Path.new( self.split( "/" )[*args].join( "/" ) ); end
+	
+		def absolute
+			if self =~ %r{^\w}
+				Path.new( File.join( self.class.getwd, self ) )
+			else
+				new_str = self.to_s
+				new_str.gsub!( %r{^\.\.}, self.class.getwd + '/..' )
+				new_str.gsub!( %r{^\.}, self.class.getwd )
+				Path.new( new_str )
+			end
+		end
+		
+		def first; self.split( "/" ).first; end
+	
+		def parent
+			self =~ %r{^(.*)/(.*?)$}
+			$1
+		end
+		
+		def node
+			self =~ %r{^(.*)/(.*?)$}
+			$2
+		end
+		
+		def size; self.split( '/' ).size; end
+		
+		def strip; self.gsub( %r{^/+}, '' ).gsub( %r{/+$}, '' ); end
+	end
+end

data/lib/filesystem.rb~

@@ -0,0 +1,343 @@
+require 'delegate'
+require 'extensions/all'
+require 'fileutils'
+require 'singleton'
+
+# FileSystem is a test-obsessed library for mocking out the entire file system.
+# It provides mock objects that clone the functionality of File, FileUtils, 
+# Dir, and other in-Ruby file-access libraries.
+# 
+# To use FileSystem in your production code, call FileSystem.get_[ class ].
+#
+#   FileSystem.get_file               => File
+#   FileSystem.get_file_utils         => FileUtils
+#   FileSystem.get_dir                => Dir
+#   FileSystem.get_dir.entries( '.' ) => [".", "..", ...]
+#
+# Then, to turn these into mock instances for a test case, simply call
+#
+#   FileSystem.mock = true
+#
+# When you've done this, the normal calls will actually return adapters that
+# pretend to be the class in question:
+#
+#   FileSystem.get_file               => FileSystem::FileAdapter
+#   FileSystem.get_file_utils         => FileSystem::FileUtilsAdapter
+#   FileSystem.get_dir                => FileSystem::DirAdapter
+#   FileSystem.get_dir.entries( '.' ) => [".", "..", ...]
+#
+# You can get direct access to the enclosed MockFileSystem by calling 
+# FileSystem.mock_file_system.
+module FileSystem
+	Version = '0.1'
+
+	@@mock = false
+	
+	def self.method_missing( symbol, *args ) #:nodoc:
+		class_name = nil
+		if symbol.id2name =~ /^get_(.*)/
+			class_name = $1.capitalize
+			class_name.gsub!( /_(\w)/ ) { |s| $1.capitalize }
+			unless %w( Dir File FileUtils ).include?( class_name )
+				class_name = nil
+			end
+		end
+		if class_name
+			if @@mock
+				return_class = Class.by_name( 'FileSystem::' + class_name + 'Adapter' )
+			else
+				return_class = Class.by_name( class_name )
+			end
+			return_class || super
+		elsif @@mock
+			mock_file_system.send( symbol, *args )
+		else
+			super
+		end
+	end
+	
+	# Tell FileSystem whether to offer interfaces to the real or mock file system.
+	# +is_mock+ should be a Boolean.
+	def self.mock= ( is_mock ); @@mock = is_mock; end
+	
+	# If we're in mock mode, this will return the MockFileSystem; otherwise it will raise a RuntimeError.
+	def self.mock_file_system
+		@@mock ? MockFileSystem.instance : ( raise RuntimeError )
+	end
+	
+	module Adapter #:nodoc:
+		@@delegated_methods = [ :delete, :entries, :mtime ]
+	
+		def get_node( nodename ); MockFileSystem.instance.get_node( nodename ); end
+		
+		def method_missing( sym, *args )
+			if @@delegated_methods.include?( sym )
+				get_node( args.first ).send( sym )
+			else
+				super
+			end
+		end
+
+		def respond_to?( sym )
+			@@delegated_methods.include?( sym ) ? true : super
+		end
+	end
+	
+	class DirAdapter #:nodoc:
+		extend Adapter
+		include Adapter
+		
+		def self.mkdir( dirname )
+			path = Path.new( dirname ).absolute
+			get_node( path.parent ).mkdir( path.node )
+		end
+		
+		def initialize( dirname )
+			unless get_node( dirname ).class == MockFileSystem::MockDir
+				raise Errno::ENOTDIR 
+			end
+		end
+	end
+	
+	class FileAdapter #:nodoc:
+		extend Adapter
+	
+		def self.chmod( perms, *filenames )
+			get_node( filenames.first ).permissions = perms
+		end
+		
+		class << self
+			def exist?( filename )
+				begin
+					get_node( filename )
+					true
+				rescue Errno::ENOENT
+					false
+				end
+			end
+			
+			alias_method :exists?, :exist?
+		end
+		
+		def self.open( fd, mode_string = File::RDONLY, &action )
+			if mode_string.class == String
+				if mode_string == 'w'
+					mode_string = File::WRONLY
+				end
+			end
+			if mode_string == File::RDONLY
+				node = get_node( fd )
+				if node && node.permissions && node.permissions[0] == 0
+					raise Errno::EACCES
+				end
+				result = action.call( node )
+				node.rewind
+				result
+			else
+				path = Path.new( fd ).absolute
+				dir = get_node( path.parent )
+				if ( mode_string & File::APPEND > 0 )
+					mock_file = get_node( fd )
+				else
+					mock_file = MockFileSystem::MockFile.new( dir, path.node, '' )
+				end
+				if ( mode_string & File::APPEND == File::APPEND )
+					mock_file.pos = mock_file.size
+				end
+				action.call( mock_file )
+				mock_file.rewind
+				if ( mode_string & File::APPEND == 0 )
+					dir[path.node] = mock_file
+				end
+			end
+		end
+	end
+	
+	class FileUtilsAdapter #:nodoc:
+		extend Adapter
+		
+		def self.cp( src, dest, options = {} )
+			file = get_node( src ).clone
+			dest_path = Path.new( dest ).absolute
+			dest_dir = get_node( dest_path.parent )
+			dest_dir[dest_path.node] = file
+			file.name = dest_path.node
+			file.parent = dest_dir
+		end
+		
+		def self.mv( src, dest, options = {} )
+			cp( src, dest, options )
+			FileSystem.get_file.delete( src )
+		end
+	
+		def self.touch( file )
+			begin
+				get_node( file ).mtime = Time.now
+			rescue Errno::ENOENT
+				path = Path.new( file ).absolute
+				parent_dir = get_node( path.parent )
+				file = MockFileSystem::MockFile.new( parent_dir, path.node, '' )
+				parent_dir[path.node] = file
+			end
+		end
+	end
+	
+	# The MockFileSystem is the singleton class that pretends to be the file system in mock mode. When it's first created, it fills in one path up to your real directory location; other paths will have to be filled by hand using +fill_path+.
+	class MockFileSystem
+		include Singleton
+		
+		# Flushes all file information out of the MockFileSystem.
+		def self.flush; instance.flush; end
+		
+		def initialize #:nodoc:
+			flush
+		end
+		
+		# Flushes all file information out of the MockFileSystem.
+		def flush; @root = MockRoot.new( '' ); fill_path( '.' ); end
+		
+		def get_node( dirname ) #:nodoc:
+			@root.get_node( dirname )
+		end
+		
+		# Use this method to fill in directory paths. This is the same as calling mkdir a bunch of times.
+		#
+		#   FileSystem.mock_file_system.fill_path '/usr/local/bin'
+		#   FileSystem.mock_file_system.fill_path '/home/francis/Desktop/myproject/'
+		def fill_path( dirname )
+			@root.fill_path( Path.new( dirname ).absolute.strip )
+		end
+		
+		module Node #:nodoc:
+			attr_accessor :mtime, :name, :parent, :permissions
+		end
+		
+		class MockDir < DelegateClass( Hash ) #:nodoc:
+			include Node
+			
+			def initialize( name, parent = nil )
+				super( {} )
+				@name, @parent = name, parent
+				@mtime = Time.now
+			end
+			
+			def []= ( name, child )
+				super
+				@mtime = child.mtime
+			end
+			
+			def delete( child = nil )
+				child ? super( child.name ) : parent.delete( self )
+			end
+			
+			def entries; %w( . .. ).concat( keys ); end
+			
+			def get_node( dirname )
+				if dirname.first == '..'
+					self.parent.get_node( dirname[1..-1] )
+				elsif dirname.first == '.'
+					self.get_node( dirname[1..-1] )
+				elsif dirname.size > 1
+					subdir = self[dirname.first]
+					subdir ? subdir.get_node( dirname[1..-1] ) : ( raise Errno::ENOENT )
+				elsif dirname == ''
+					self
+				else
+					self[dirname.strip] or ( raise Errno::ENOENT )
+				end
+			end
+			
+			def fill_dir( dirname )
+				dir = self[dirname]
+				if dir.nil?
+					dir = MockDir.new( dirname, self )
+					self[dirname] = dir
+					@mtime = dir.mtime
+				end
+				dir
+			end
+			
+			def fill_path( dirname )
+				if dirname.size > 1
+					dir = fill_dir( dirname.first )
+					dir.fill_path( dirname[1..-1] )
+				else
+					fill_dir( dirname )
+				end
+			end
+			
+			def mkdir( dirname ); fill_path( Path.new( dirname ) ); end
+		end
+		
+		class MockFile < DelegateClass( StringIO ) #:nodoc:
+			include Node
+			
+			attr_writer :contents
+		
+			def initialize( parent, name, contents )
+				@name = name; @parent = parent; @mtime = Time.now
+				contents = contents || ''
+				super( StringIO.new( contents ) )
+			end
+			
+			def clone
+				rewind
+				clone = self.class.new( @parent, @name, gets( nil ) )
+				clone.mtime = @mtime
+				clone
+			end
+
+			def delete; parent.delete( self ); end
+			
+			def gets( sep_string = $/ ); super( sep_string ) || ''; end
+		end
+		
+		class MockRoot < MockDir #:nodoc:
+			def get_node( dirname )
+				begin
+					super( Path.new( dirname ).absolute.strip )
+				rescue Errno::ENOENT
+					raise Errno::ENOENT.new( dirname )
+				end
+			end
+		end
+	end
+	
+	class Path < String #:nodoc:
+		@@getwd = nil
+		
+		def self.getwd
+			@@getwd = Dir.getwd if @@getwd.nil?
+			@@getwd
+		end
+	
+		def []( *args ); Path.new( self.split( "/" )[*args].join( "/" ) ); end
+	
+		def absolute
+			if self =~ %r{^\w}
+				Path.new( File.join( self.class.getwd, self ) )
+			else
+				new_str = self.to_s
+				new_str.gsub!( %r{^\.\.}, self.class.getwd + '/..' )
+				new_str.gsub!( %r{^\.}, self.class.getwd )
+				Path.new( new_str )
+			end
+		end
+		
+		def first; self.split( "/" ).first; end
+	
+		def parent
+			self =~ %r{^(.*)/(.*?)$}
+			$1
+		end
+		
+		def node
+			self =~ %r{^(.*)/(.*?)$}
+			$2
+		end
+		
+		def size; self.split( '/' ).size; end
+		
+		def strip; self.gsub( %r{^/+}, '' ).gsub( %r{/+$}, '' ); end
+	end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.1
+specification_version: 1
+name: filesystem
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2005-02-16
+summary: FileSystem is a test-obsessed library for mocking out the entire file system.
+require_paths: 
+  - lib
+author: Francis Hwang
+email: sera@fhwang.net
+homepage: http://filesystem.rubyforge.org/
+rubyforge_project: 
+description: "FileSystem is a test-obsessed library for mocking out the entire file system. It
+  provides mock objects that clone the functionality of File, FileUtils, Dir, and
+  other in-Ruby file-access libraries."
+autorequire: filesystem
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+files: 
+  - lib/filesystem.rb
+  - lib/filesystem.rb~
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: extensions
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">"
+          - !ruby/object:Gem::Version 
+            version: 0.0.0
+      version: