rubypath 0.1.0

data/lib/rubypath/backend/sys.rb

@@ -0,0 +1,139 @@
+class Path::Backend
+
+  #
+  class Sys
+
+    def initialize(root = nil)
+      @root  = ::File.expand_path root if root
+      @umask = File.umask
+    end
+
+    def quit
+      File.umask @umask
+    end
+
+    def home(user)
+      ::File.expand_path "~#{user}"
+    end
+
+    def getwd
+      ::Dir.getwd
+    end
+
+    def user
+      require 'etc'
+
+      Etc.getlogin
+    end
+
+    def r(path)
+      return path unless @root
+      ::File.expand_path("#{@root}/#{::File.expand_path(path)}")
+    end
+
+    def ur(path)
+      return path unless @root
+
+      if path.slice(0, @root.length) == @root
+        path.slice(@root.length, path.length - @root.length)
+      else
+        path
+      end
+    end
+
+    def fs(path, obj, method, *args)
+      # puts "[FS] #{obj} #{method} #{args.inspect}"
+      obj.send method, *args
+    rescue Errno::ENOENT
+      raise Errno::ENOENT.new path
+    rescue Errno::EISDIR
+      raise Errno::EISDIR.new path
+    rescue Errno::ENOTDIR
+      raise Errno::ENOTDIR.new path
+    end
+
+    ## OPERATIONS
+
+    def expand_path(path, base)
+      ::File.expand_path path, base
+    end
+
+    def exists?(path)
+      fs path, ::File, :exists?, r(path)
+    end
+
+    def mkdir(path)
+      fs path, ::Dir, :mkdir, r(path)
+    end
+
+    def mkpath(path)
+      fs path, ::FileUtils, :mkdir_p, r(path)
+    end
+
+    def directory?(path)
+      fs path, ::File, :directory?, r(path)
+    end
+
+    def file?(path)
+      fs path, ::File, :file?, r(path)
+    end
+
+    def touch(path)
+      fs path, ::FileUtils, :touch, r(path)
+    end
+
+    def write(path, content, *args)
+      fs path, ::IO, :write, r(path), content, *args
+    end
+
+    def read(path, *args)
+      fs path, ::IO, :read, r(path), *args
+    end
+
+    def mtime(path)
+      fs path, ::File, :mtime, r(path)
+    end
+
+    def mtime=(path, time)
+      fs path, ::File, :utime, atime(path), time, r(path)
+    end
+
+    def atime(path)
+      fs path, ::File, :atime, r(path)
+    end
+
+    def atime=(path, time)
+      fs path, ::File, :utime, time, mtime(path), r(path)
+    end
+
+    def entries(path)
+      fs path, ::Dir, :entries, r(path)
+    end
+
+    def glob(pattern, flags = 0, &block)
+      if block_given?
+        fs pattern, ::Dir, :glob, r(pattern), flags do |path|
+          yield ur(path)
+        end
+      else
+        fs(pattern, ::Dir, :glob, r(pattern), flags).map{|path| ur path }
+      end
+    end
+
+    def get_umask
+      File.umask
+    end
+
+    def set_umask(mask)
+      File.umask mask
+    end
+
+    def mode(path)
+      fs(path, ::File, :stat, r(path)).mode & 0777
+    end
+
+    def chmod(path, mode)
+      fs path, ::File, :chmod, mode, r(path)
+    end
+  end
+end

data/lib/rubypath/backend.rb

@@ -0,0 +1,87 @@
+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
+  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/comparison.rb

@@ -0,0 +1,22 @@
+class Path
+  # @!group Comparison
+
+  # Compare path to given object. If object is a string, Path or #{Path.like?}
+  # they will be compared using the string paths. Otherwise they are assumed
+  # as not equal.
+  #
+  # @param other [Object] Object to compare path with.
+  # @return [Boolean] True if object represents same path.
+  #
+  def eql?(other)
+    case other
+      when String
+        internal_path.eql? other
+      when Path
+        internal_path.eql? other.path
+      else
+        Path.new(other).eql?(self) if Path.like? other
+    end
+  end
+  alias_method :==, :eql?
+end

data/lib/rubypath/construction.rb

@@ -0,0 +1,109 @@
+class Path
+
+  class << self
+    # @!group Construction
+
+    # Create new {Path}.
+    #
+    # If single argument is a path object it will be returned and no new one
+    # will be created. If not arguments are given {Path::EMPTY} will be
+    # returned.
+    #
+    # @see #initialize
+    #
+    def new(*args)
+      args.flatten!
+      return Path::EMPTY if args.empty?
+      return args.first if args.size == 1 && args.first.is_a?(self)
+      super
+    end
+
+    # Check if given object is like a path.
+    #
+    # An object is like a path if
+    # 1. It is a {Path} object.
+    # 2. It is a string.
+    # 3. It responds to {#to_path} and {#to_path} returns a string.
+    # 4. It responds to {#path} and {#path} returns a string.
+    #
+    # If no rule matches it is not considered to be like a path.
+    #
+    # @return [Boolean] True if object is path like, false otherwise.
+    #
+    def like?(obj)
+      return true if obj.is_a?(self)
+      return true if obj.is_a?(String)
+      return true if obj.respond_to?(:to_path) && obj.to_path.is_a?(String)
+      return true if obj.respond_to?(:path) && obj.path.is_a?(String)
+      false
+    end
+
+    # Convert given object to path string using {::Path.like?} rules.
+    #
+    # @note Should not be used directly.
+    #
+    # @return [String]
+    # @raise [ArgumentError] If given object is not {::Path.like?}.
+    # @see ::Path.like?
+    #
+    def like_path(obj)
+      case obj
+        when String
+          return obj
+        else
+          [:to_path, :path, :to_str, :to_s].each do |mth|
+            if obj.respond_to?(mth) && obj.send(mth).is_a?(String)
+              return obj.send(mth)
+            end
+          end
+      end
+
+      raise ArgumentError.new \
+        "Argument #{obj.inspect} cannot be converted to path string."
+    end
+
+    # Return system file path separator.
+    #
+    # @return [String] File separator.
+    # @see ::File::SEPARATOR
+    #
+    def separator
+      ::File::SEPARATOR
+    end
+
+    # Allow class object to be used as a bock.
+    #
+    # @example
+    #   %w(path/to/fileA path/to/fileB).map(&Path)
+    #
+    def to_proc
+      proc {|*args| Path.new(*args) }
+    end
+  end
+
+  # @!group Construction
+
+  # Initialize new {Path} object.
+  #
+  # Given arguments will be converted to String using `#to_path`, `#path` or
+  # `#to_s` in this order if they return a String object.
+  #
+  # @overload initialize([[String, #to_path, #path, #to_s], ...]
+  #
+  def initialize(*args)
+    parts = args.flatten
+    @path = if parts.size > 1
+              ::File.join(*parts.map{|p| Path.like_path p })
+            elsif parts.size == 1
+              Path.like_path(parts.first).dup
+            else
+              ''
+            end
+  end
+
+  # Empty path.
+  #
+  # @return [Path] Empty path.
+  #
+  EMPTY = Path.new('')
+end

data/lib/rubypath/dir_operations.rb

@@ -0,0 +1,76 @@
+class Path
+  class << self
+
+    # Returns the current working directory.
+    #
+    # @return [Path] Current working directory.
+    # @see ::Dir.getwd
+    #
+    def getwd
+      new Backend.instance.getwd
+    end
+
+    def glob(pattern, flags = ::File::FNM_EXTGLOB)
+      if block_given?
+        Backend.instance.glob(pattern, flags) {|path| yield Path path }
+      else
+        Backend.instance.glob(pattern, flags).map(&Path)
+      end
+    end
+  end
+
+  # Create directory.
+  #
+  # Given arguments will be joined with current path before directory is
+  # created.
+  #
+  # @raise [Errno::ENOENT] If parent directory could not created.
+  # @return [Path] Path to created directory.
+  # @see #mkpath
+  #
+  def mkdir(*args)
+    with_path(*args) do |path|
+      Backend.instance.mkdir path
+      Path path
+    end
+  end
+
+  # Create directory and all missing parent directories.
+  #
+  # Given arguments will be joined with current path before directories
+  # are created.
+  #
+  # @return [Path] Path to created directory.
+  # @see #mkdir
+  # @see ::FileUtils.mkdir_p
+  #
+  def mkpath(*args)
+    with_path(*args) do |path|
+      Backend.instance.mkpath path
+      Path path
+    end
+  end
+  alias_method :mkdir_p, :mkpath
+
+  # Return list of entries in directory. That includes special directories
+  # (`.`, `..`).
+  #
+  # Given arguments will be joined before children are listed for directory.
+  #
+  # @return [Array<Path>] Entries in directory.
+  #
+  def entries(*args)
+    invoke_backend(:entries, internal_path).map(&Path)
+  end
+
+  #
+  def glob(pattern, flags = ::File::FNM_EXTGLOB)
+    Path.glob ::File.join(escaped_glob_path, pattern), flags
+  end
+
+  private
+
+  def escaped_glob_path
+    internal_path.gsub(/[\[\]\*\?\{\}]/, '\\\\\0')
+  end
+end

data/lib/rubypath/extensions.rb

@@ -0,0 +1,157 @@
+class Path
+  # @!group File Extensions
+
+  # Return list of all file extensions.
+  #
+  # @example
+  #   Path.new('/path/to/template.de.html.erb').extensions
+  #   #=> ['de', 'html', 'erb']
+  #
+  # @return [Array<String>] List of file extensions.
+  #
+  def extensions
+    if dotfile?
+      name.split('.')[2..-1]
+    else
+      name.split('.')[1..-1]
+    end
+  end
+  alias_method :exts, :extensions
+
+  # Return last file extension.
+  #
+  # @example
+  #   Path.new('/path/to/template.de.html.erb').extension
+  #   #=> 'erb'
+  #
+  # @return [String] Last file extensions.
+  #
+  def extension
+    extensions.last
+  end
+  alias_method :ext, :extension
+
+  # Return last file extension include dot character.
+  #
+  # @return [String] Ext name.
+  # @see ::File.extname
+  #
+  def extname
+    ::File.extname name
+  end
+
+  # Return the file name without any extensions.
+  #
+  # @example
+  #   Path("template.de.html.slim").pure_name
+  #   #=> "template"
+  #
+  # @example
+  #   Path("~/.gitconfig").pure_name
+  #   #=> ".gitconfig"
+  #
+  # @return [String] File name without extensions.
+  #
+  def pure_name
+    if dotfile?
+      name.split('.', 3)[0..1].join('.')
+    else
+      name.split('.', 2)[0]
+    end
+  end
+
+  # Replace file extensions with given new ones or by a given
+  # translation map.
+  #
+  # @overload replace_extensions(exts)
+  #   Replace all extensions with given new ones. Number of given extensions
+  #   does not need to match number of existing extensions.
+  #
+  #   @example
+  #     Path('file.de.txt').replace_extensions(%w(en html))
+  #     #=> <Path "file.en.html">
+  #
+  #   @example
+  #     Path('file.de.mobile.html.haml').replace_extensions(%w(int txt))
+  #     #=> <Path "file.int.txt">
+  #
+  #   @param exts [Array<String>] New extensions.
+  #
+  # @overload replace_extensions(ext, [ext, [..]])
+  #   Replace all extensions with given new ones. Number of given extensions
+  #   does not need to match number of existing extensions.
+  #
+  #   @example
+  #     Path('file.de.txt').replace_extensions('en', 'html')
+  #     #=> <Path "file.en.html">
+  #
+  #   @example
+  #     Path('file.de.mobile.html.haml').replace_extensions('en', 'html')
+  #     #=> <Path "file.en.html">
+  #
+  #   @example
+  #     Path('file.de.txt').replace_extensions('html')
+  #     #=> <Path "file.html">
+  #
+  #   @param ext [String] New extensions.
+  #
+  # @overload replace_extensions(map)
+  #   Replace all matching extensions.
+  #
+  #   @example
+  #     Path('file.de.html.haml').replace_extensions('de' => 'en', 'haml' => 'slim')
+  #     #=> <Path "file.en.html.slim">
+  #
+  #   @param map [Hash<String, String>] Translation map as hash.
+  #
+  # @return [Path] Path to new filename.
+  #
+  def replace_extensions(*args)
+    args.flatten!
+    extensions = self.extensions
+
+    if (replace = (args.last.is_a?(Hash) ? args.pop : nil))
+      if args.empty?
+        extensions.map! do |ext|
+          replace[ext] ? replace[ext].to_s : ext
+        end
+      else
+        raise ArgumentError.new 'Cannot replace extensions with array ' \
+                                'and hash at the same time.'
+      end
+    else
+      extensions = args.map(&:to_s)
+    end
+
+    if extensions == self.extensions
+      self
+    else
+      if only_filename?
+        Path "#{pure_name}.#{extensions.join('.')}"
+      else
+        dirname.join "#{pure_name}.#{extensions.join('.')}"
+      end
+    end
+  end
+
+  # Replace last extension with one or multiple new extensions.
+  #
+  # @example
+  #   Path('file.de.txt').replace_extension('html')
+  #   #=> <Path "file.de.html">
+  #
+  # @example
+  #   Path('file.de.txt').replace_extension('html', 'erb')
+  #   #=> <Path "file.de.html.erb">
+  #
+  # @return [Path] Path to new filename.
+  #
+  def replace_extension(*args)
+    extensions = self.extensions
+    extensions.pop
+    extensions += args.flatten
+
+    replace_extensions extensions
+  end
+
+end