rubypath 1.0.0 → 1.0.1

data/lib/rubypath/extensions.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+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 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 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.
+  #
+  # rubocop:disable AbcSize
+  # rubocop:disable CyclomaticComplexity
+  # rubocop:disable MethodLength
+  # rubocop:disable PerceivedComplexity
+  #
+  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
+    elsif only_filename?
+      Path "#{pure_name}.#{extensions.join('.')}"
+    else
+      dirname.join "#{pure_name}.#{extensions.join('.')}"
+    end
+  end
+  # rubocop:enable all
+
+  # 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

data/lib/rubypath/file_operations.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+class Path
+  # @!group File Operations
+
+  # Return base name without path.
+  #
+  # @return [String] Base name.
+  #
+  def name
+    ::File.basename internal_path
+  end
+  alias basename name
+
+  # Create new file at pointed location or update modification time if file
+  # exists.
+  #
+  # @example
+  #   Path('/path/to/file.txt').touch
+  #   #=> <Path:"/path/to/file.txt">
+  #
+  # @example
+  #   Path('/path/to').touch('file.txt')
+  #   #=> <Path:"/path/to/file.txt">
+  #
+  # @return [Path] Path to touched file.
+  #
+  def touch(*args)
+    with_path(*args) do |path|
+      invoke_backend :touch, path
+      Path path
+    end
+  end
+
+  # Removes file at current path.
+  #
+  # Raise an error if file does not exists or is a directory.
+  #
+  # @example
+  #   Path('/file.txt').touch.unlink
+  #   #=> <Path /file.txt>
+  #
+  # @example
+  #   Path('/file.txt').touch
+  #   Path('/').unlink('file.txt')
+  #   #=> <Path /file.txt>
+  #
+  # @return [Path] Unlinked path.
+  #
+  def unlink(*args)
+    with_path(*args) do |path|
+      invoke_backend :unlink, path
+      Path path
+    end
+  end
+
+  # Create a file at pointed location and all missing parent directories.
+  #
+  # Given arguments will be joined with current path before directories and
+  # file is created.
+  #
+  # If file already exists nothing will be done.
+  #
+  # @example
+  #   Path('/path/to/file.txt').mkfile
+  #   #=> <Path:"/path/to/file.txt">
+  #
+  # @example
+  #   Path('/').mkfile('path', 'to', 'file.txt')
+  #   #=> <Path:"/path/to/file.txt">
+  #
+  # @return [Path] Path to created or existent file.
+  #
+  def mkfile(*args) # rubocop:disable AbcSize
+    with_path(*args) do |path|
+      path.parent.mkpath if !path.exists? && path.parent && !path.parent.exists?
+
+      if path.exists?
+        raise Errno::ENOENT.new path.to_s unless path.file?
+      else
+        path.touch
+      end
+    end
+  end
+
+  # Search for a file in current directory or parent directories.
+  #
+  # Given search pattern can either be a regular expression or a shell glob
+  # expression.
+  #
+  # @example
+  #   Path.cwd.lookup('project.{yml,yaml}')
+  #   #=> <Path:"/path/config.yml">
+  #
+  # @example
+  #   Path.cwd.lookup(/config(_\d+).ya?ml/)
+  #   #=> <Path:"/path/config_354.yaml">
+  #
+  # @example
+  #   Path('~').lookup('*config', ::File::FNM_DOTMATCH)
+  #   #=> <Path:"/gome/user/.gitconfig">
+  #
+  # @param pattern [String|RegExp] Expression file name must match.
+  # @param flags [Integer] Additional flags. See {::File.fnmatch}.
+  #   Defaults to `File::FNM_EXTGLOB`.
+  # @return [Path] Path to found file or nil.
+  #
+  def lookup(pattern, flags = nil) # rubocop:disable MethodLength
+    flags = self.class.default_glob_flags(flags)
+
+    expand.ascend do |path|
+      case pattern
+        when String
+          path.entries.each do |c|
+            return path.join(c) if ::File.fnmatch?(pattern, c.name, flags)
+          end
+        when Regexp
+          path.entries.each do |c|
+            # rubocop:disable RegexpMatch
+            return path.join(c) if pattern =~ c.name
+          end
+      end
+    end
+
+    nil
+  end
+  # rubocop:enable all
+
+  # Return file modification time.
+  #
+  # @return [Time] Time of last modification.
+  #
+  def mtime
+    invoke_backend :mtime
+  end
+
+  # Set last modification time.
+  #
+  # @param [Time] Time of last modification.
+  #
+  def mtime=(time)
+    invoke_backend :mtime=, internal_path, time
+  end
+
+  # Return file access time.
+  #
+  # @return [Time] Time of last access.
+  #
+  def atime
+    invoke_backend :atime
+  end
+
+  # Set last access time.
+  #
+  # @param [Time] Time of last access.
+  #
+  def atime=(time)
+    invoke_backend :atime=, internal_path, time
+  end
+
+  def mode
+    invoke_backend :mode
+  end
+
+  def chmod(mode)
+    invoke_backend :chmod, internal_path, mode
+  end
+
+  class << self
+    # Read or set process umask.
+    #
+    # @overload umask
+    #   Read process umask.
+    #
+    #   @return [Integer] Process umask.
+    #
+    # @overload umask(mask)
+    #   Set process umask.
+    #
+    #   @param mask [Integer] New process umask.
+    #
+    # @see File.umask
+    #
+    def umask(mask = nil)
+      if mask
+        invoke_backend :umask=, mask
+      else
+        invoke_backend :umask
+      end
+    end
+    alias umask= umask
+  end
+end

data/lib/rubypath/file_predicates.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Path
+  # @!group File Predicates
+
+  # Check if path points to file.
+  #
+  # @return [Boolean] True if path is a file.
+  # @see ::File.file?
+  #
+  def file?
+    invoke_backend :file?
+  end
+
+  # Check if path points to an existing location.
+  #
+  # @return [Boolean] True if path exists.
+  # @see ::File.exists?
+  #
+  def exists?
+    invoke_backend :exists?
+  end
+  alias exist? exists?
+  alias existent? exists?
+
+  # Check if path points to a directory.
+  #
+  # @return [Boolean] True if path is a directory.
+  # @see ::File.directory?
+  #
+  def directory?
+    invoke_backend :directory?
+  end
+end

data/lib/rubypath/identity.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class Path
+  # @!group Identity
+
+  # Return path as string. String will be duped before it gets returned and
+  # cannot be used to modify the path object.
+  #
+  # @return [String] Path as string.
+  def path
+    internal_path.dup
+  end
+  alias to_path path
+  alias to_str path
+  alias to_s path
+
+  # Return a useful object string representation.
+  #
+  # @return [String] Useful object representation
+  def inspect
+    "<#{self.class.name}:#{internal_path}>"
+  end
+
+  protected
+
+  # Return internal path object without duping.
+  #
+  # Must not be modified to not change internal state.
+  #
+  # @return [String] Internal path.
+  # @see #path
+  #
+  def internal_path
+    @path
+  end
+
+  # If arguments are provided the current path will be joined with given
+  # arguments to the result will be yielded. If no arguments are given the
+  # current path will be yielded.
+  #
+  # Internal helper method.
+  #
+  # @example
+  #   def handle_both(*args)
+  #     with_path(*args) do |path|
+  #       # do something
+  #     end
+  #   end
+  #
+  # Returns whatever the block returns.
+  #
+  def with_path(*args)
+    if args.any?
+      yield join(*args)
+    else
+      yield self
+    end
+  end
+end