rubypath 0.3.2 → 1.0.0

data/lib/rubypath.rb

@@ -1,29 +0,0 @@
-require 'rubypath/version'
-require 'tmpdir'
-
-#
-#
-#
-class Path
-  require 'rubypath/identity'
-  require 'rubypath/construction'
-  require 'rubypath/comparison'
-  require 'rubypath/extensions'
-
-  require 'rubypath/path_operations'
-  require 'rubypath/path_predicates'
-  require 'rubypath/file_operations'
-  require 'rubypath/file_predicates'
-  require 'rubypath/dir_operations'
-  require 'rubypath/io_operations'
-
-  require 'rubypath/mock'
-  require 'rubypath/backend'
-
-end
-
-module Kernel
-  def Path(*args)
-    Path.new *args
-  end
-end

data/lib/rubypath/backend.rb

@@ -1,92 +0,0 @@
-class Path
-  class Backend
-    class << self
-      def instance
-        @instance ||= new
-      end
-
-      def delegate(mth)
-        define_method mth do |*args|
-          backend.send mth, *args
-        end
-      end
-
-      def mock(*args, &block)
-        self.instance.mock(*args, &block)
-      end
-    end
-
-    attr_accessor :backend
-    def initialize
-      self.backend = Backend::Sys.new
-    end
-
-    def mock(opts = {}, &block)
-      if opts[:root]
-        # Use real file system scoped to given directory (chroot like)
-        if opts[:root] == :tmp
-          ::Dir.mktmpdir('rubypath') do |path|
-            use_backend Backend::Sys.new(path), &block
-          end
-        else
-          use_backend Backend::Sys.new(opts[:root]), &block
-        end
-      else
-        # Use mock FS
-        use_backend Backend::Mock.new, &block
-      end
-    end
-
-    def use_backend(be)
-      old_backend, self.backend = backend, be
-      yield
-      backend.quit if backend.respond_to? :quit
-      self.backend = old_backend
-    end
-
-    delegate :expand_path
-    delegate :getwd
-    delegate :exists?
-    delegate :mkdir
-    delegate :mkpath
-    delegate :directory?
-    delegate :file?
-    delegate :touch
-    delegate :write
-    delegate :read
-    delegate :mtime
-    delegate :mtime=
-    delegate :entries
-    delegate :glob
-    delegate :atime
-    delegate :atime=
-    delegate :get_umask
-    delegate :set_umask
-    delegate :mode
-    delegate :chmod
-    delegate :unlink
-    delegate :rmtree
-    delegate :rmtree!
-    delegate :safe_rmtree
-    delegate :safe_rmtree!
-  end
-
-  private
-
-  def invoke_backend(mth, *args)
-    args << self if args.empty?
-    self.class.send :invoke_backend, mth, *args
-  end
-
-  class << self
-
-    private
-
-    def invoke_backend(mth, *args)
-      Backend.instance.send mth, *args
-    end
-  end
-
-  require 'rubypath/backend/mock'
-  require 'rubypath/backend/sys'
-end

data/lib/rubypath/backend/mock.rb

@@ -1,356 +0,0 @@
-class Path::Backend
-
-  class Mock
-    attr_reader :user, :homes
-
-    # @!group Virtual File System Configuration
-
-    # Set user that owns the current process.
-    def current_user=(user)
-      @user = user.to_s
-    end
-
-    # Define new home directories. Must be given as has a hash that is
-    # interpreted as a user name to home directory mapping.
-    attr_writer :homes
-
-    # Set current working directory.
-    attr_writer :cwd
-
-    # @!group Internal Methods
-
-    def initialize
-      @user  = 'root'
-      @homes = {'root' => '/root'}
-      @cwd   = '/root'
-      @umask = 0022
-    end
-
-    def home(user)
-      homes.fetch(user){ raise ArgumentError.new "user #{user} doesn't exist" }
-    end
-
-    # @!group Backend Operations
-
-    def expand_path(path, base = getwd)
-      if %r{^~(?<name>[^/]*)(/(?<rest>.*))?$} =~ path
-        ::File.expand_path rest.to_s, home(name.empty? ? user : name)
-      else
-        ::File.expand_path(path, base)
-      end
-    end
-    alias_method :expand, :expand_path
-
-    def getwd
-      @cwd ||= '/'
-    end
-
-    def file?(path)
-      lookup(path).is_a?(File)
-    end
-
-    def directory?(path)
-      lookup(path).is_a?(Dir)
-    end
-
-    def exists?(path)
-      lookup(path) ? true : false
-    end
-
-    def mkdir(path)
-      return if path.to_s == '/'
-
-      node = lookup_parent! path
-      dir  = node.lookup ::File.basename path
-      unless dir.is_a?(Dir)
-        if dir.nil?
-          node.add Dir.new(self, ::File.basename(path))
-        else
-          raise ArgumentError.new \
-            "Node #{dir.path} exists and is no directory."
-        end
-      end
-    end
-
-    def mkpath(path)
-      path = expand_path(path)
-      ::Pathname.new(path).descend do |p|
-        mkdir(p.to_s)
-      end
-    end
-
-    def touch(path)
-      node = lookup_parent! path
-      file = node.lookup ::File.basename path
-      if file
-        file.mtime = Time.now
-      else
-        node.add File.new(self, ::File.basename(path))
-      end
-    end
-
-    def write(path, content, *args)
-      node = lookup_parent! path
-      file = node.lookup ::File.basename(path)
-      unless file
-        file = File.new self, ::File.basename(path)
-        node.add file
-      end
-
-      case file
-        when File
-          if args.empty?
-            file.content = content
-          else
-            offset = args[0].to_i
-            file.content[offset, content.length] = content
-          end
-          file.mtime   = Time.now
-        when Dir
-          raise Errno::EISDIR.new path
-        else
-          raise ArgumentError.new
-      end
-    end
-
-    def mtime(path)
-      lookup!(path).mtime
-    end
-
-    def mtime=(path, time)
-      lookup!(path).mtime = time
-    end
-
-    def atime(path)
-      lookup!(path).atime
-    end
-
-    def atime=(path, time)
-      lookup!(path).atime = time
-    end
-
-    def read(path, *args)
-      file       = lookup_file!(path)
-      file.atime = Time.now
-      content    = file.content
-      if args[0]
-        length  = args[0].to_i
-        offset  = args[1] ? args[1].to_i : 0
-        content = content.slice(offset, length)
-      end
-      content
-    end
-
-    def entries(path)
-      node = lookup_dir! path
-      node.children.map(&:name) + %w(. ..)
-    end
-
-    def glob(pattern, flags = 0, &block)
-      root.all.select do |node|
-        ::File.fnmatch pattern, node.path, (flags | ::File::FNM_PATHNAME)
-      end
-    end
-
-    def get_umask
-      @umask
-    end
-
-    def set_umask(mask)
-      @umask = Integer(mask)
-    end
-
-    def mode(path)
-      lookup!(path).mode
-    end
-
-    def unlink(path)
-      node = lookup_parent!(path)
-      file = node.lookup ::File.basename path
-      case file
-        when Dir
-          raise Errno::EISDIR.new path
-        when File
-          node.children.delete(file)
-        when nil
-          raise Errno::ENOENT.new path
-        else
-          raise ArgumentError.new "Unknown node #{node.inspect} for #unlink."
-      end
-    end
-
-    def rmtree(path)
-      node = lookup path
-      case node
-        when Dir, File
-          lookup_parent!(path).children.delete(node)
-        when nil
-          nil
-        else
-          raise ArgumentError.new "Unknown node #{node.inspect} for #rmtree."
-      end
-    end
-    alias_method :safe_rmtree, :rmtree
-
-    def rmtree!(path)
-      node = lookup path
-      case node
-        when Dir, File
-          lookup_parent!(path).children.delete(node)
-        when nil
-          raise Errno::ENOENT.new path
-        else
-          raise ArgumentError.new "Unknown node #{node.inspect} for #rmtree."
-      end
-    end
-    alias_method :safe_rmtree!, :rmtree!
-
-    # @!group Internal Virtual File System
-
-    # Return root node.
-    def root
-      @root ||= Dir.new(self, '')
-    end
-
-    def to_lookup(path)
-      path = expand path
-      path.sub(/^\/+/, '')
-    end
-
-    def lookup(path)
-      root.lookup to_lookup path
-    end
-
-    def lookup!(path)
-      if (node = lookup(path))
-        node
-      else
-        raise Errno::ENOENT.new path
-      end
-    end
-
-    def lookup_file!(path)
-      node = lookup! path
-      case node
-        when File
-          node
-        when Dir
-          raise Errno::EISDIR.new path
-        else
-          raise ArgumentError.new "NOT A FILE: #{path}"
-      end
-    end
-
-    def lookup_dir!(path)
-      if (node = lookup!(path)).is_a?(Dir)
-        node
-      else
-        raise Errno::ENOENT.new path
-      end
-    end
-
-    def lookup_parent!(path)
-      node = lookup ::File.dirname expand path
-      if node
-        node.is_a?(Dir) ? node : raise(Errno::ENOTDIR.new path)
-      else
-        raise Errno::ENOENT.new path
-      end
-    end
-
-    #
-    class Node
-      attr_reader :sys, :name, :parent
-      attr_accessor :mtime, :atime, :mode
-
-      def initialize(backend, name, ops = {})
-        @sys   = backend
-        @name  = name
-        @mtime = Time.now
-        @atime = Time.now
-      end
-
-      def mtime=(time)
-        if time.is_a?(Time)
-          @mtime = time
-        else
-          raise "Not Time but `#{time.inspect}` of `#{time.class.name}` given."
-        end
-      end
-
-      def lookup(path)
-        raise NotImplementError.new 'Subclass responsibility.'
-      end
-
-      def added(parent)
-        @parent = parent
-      end
-
-      def path
-        parent ? "#{parent.path}/#{name}" : name
-      end
-    end
-
-    #
-    class Dir < Node
-      def initialize(backend, name, opts = {})
-        super
-        self.mode = 0777 - backend.get_umask
-      end
-
-      def lookup(path)
-        name, rest = path.to_s.split('/', 2).map(&:to_s)
-
-        if name.nil?
-          if rest.nil?
-            self
-          else
-            lookup rest
-          end
-        else
-          child = children.find{|c| c.name == name }
-          if child
-            rest.nil? ? child : child.lookup(rest)
-          else
-            nil
-          end
-        end
-      end
-
-      def add(node)
-        if children.any?{|c| c.name == node.name }
-          raise ArgumentError.new "Node #{path}/#{node.name} already exists."
-        else
-          children << node
-          node.added self
-        end
-      end
-
-      def all
-        children.reduce([]) do |memo, child|
-          memo << child
-          memo += child.all if child.is_a?(Dir)
-          memo
-        end
-      end
-
-      def children
-        @children ||= []
-      end
-    end
-
-    #
-    class File < Node
-      attr_accessor :content
-
-      def initialize(backend, name, opts = {})
-        super
-        self.mode = 0666 - backend.get_umask
-      end
-
-      def lookup(path)
-        nil
-      end
-    end
-  end
-end