rubypath 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 132e274110300f64504251d3ff47c352bbfe15c8
-  data.tar.gz: cc3628865507096713d6e783af1b24f1235e0ff1
+  metadata.gz: 5e7333efb5dc342354d834cbbca3ce7fd6bc4e77
+  data.tar.gz: fa82812dd3e0b30f7989b7677f2b5f3d9e02e041
 SHA512:
-  metadata.gz: f52446607fddc79bd5da72f4e77eacfb282f3d817ae7331740513b694ccf6a905760897023801b9ce96d41119bc26f701f37ca12fb9400a53904b3586ed77f38
-  data.tar.gz: 30bda5d8a6d2ae40e83c040d0ad95391ec6e59f858e0e9bb636c964b6a6298fb60aa29eb081ad33647c5630a37ff31400f2c10d8eedc7ae03ef0fa3188d68090
+  metadata.gz: c57d75be4a166f7ed70675668de9bb1a9284097b11006be7e5ebb0fd173e2f937582c4a2a974be25c360886ee764be5b7fc921d258a1273f54ff26b8f377dc21
+  data.tar.gz: 9d5ae45a83991d9feaf746d64fd8b5a8e908637fb6a6e1515eb6a440f7be09a5ac6acd378bac56c2750c1a844431311e5cbaa800ddcc26d099d45ee8651b64bd

data/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changes
+
+## 1.0.1
+
+* Fix issues with gem packaging
+
+## 1.0.0
+
+* Dump to semantic versioning
+* Internal code style changes
+
+## 0.3.2
+
+* Fix infinite loop bug in #relative_from
+* Fix handling of trailing slash in #cleanpath (and depended methods)
+
+## 0.3.1
+
+* Fix missing require 'tmpdir' for using with mocked backend
+
+## 0.3.0
+
+* Add #unlink
+* Add #cleanpath
+* Add #rmtree, #rmtree!, and safe variants
+
+## 0.2.0
+
+* Add #relative_from
+
+## 0.1.0
+
+* Initial release

data/LICENSE.txt

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/lib/rubypath.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+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
+  # rubocop:disable Style/MethodName
+  def Path(*args)
+    Path.new(*args)
+  end
+end

data/lib/rubypath/backend.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+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)
+        instance.mock(*args, &block)
+      end
+    end
+
+    attr_accessor :backend
+    def initialize
+      self.backend = Backend::Sys.new
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    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
+    # rubocop:enable Metrics/MethodLength
+
+    def use_backend(be)
+      old_backend = backend
+      self.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 :umask
+    delegate :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

@@ -0,0 +1,362 @@
+# frozen_string_literal: true
+
+class Path
+  class Backend
+    # rubocop:disable Metrics/ClassLength
+    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 = 0o022
+      end
+
+      def home(user)
+        homes.fetch(user) do
+          raise ArgumentError.new "user #{user} doesn't exist"
+        end
+      end
+
+      # @!group Backend Operations
+
+      def expand_path(path, base = getwd)
+        # rubocop:disable RegexpMatch
+        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 expand expand_path
+      # rubocop:enable all
+
+      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
+        return if 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
+
+      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) # rubocop:disable AbcSize, MethodLength
+        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 = String.new(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)
+        root.all.select do |node|
+          ::File.fnmatch pattern, node.path, (flags | ::File::FNM_PATHNAME)
+        end
+      end
+
+      attr_reader :umask
+
+      def umask=(mask)
+        @umask = Integer(mask)
+      end
+
+      def mode(path)
+        lookup!(path).mode
+      end
+
+      def unlink(path) # rubocop:disable MethodLength
+        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 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 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(%r{^/+}, '')
+      end
+
+      def lookup(path)
+        root.lookup to_lookup path
+      end
+
+      def lookup!(path)
+        node = lookup path
+        return node if node
+
+        raise Errno::ENOENT.new path
+      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)
+        node = lookup! path
+        return node if node.is_a?(Dir)
+
+        raise Errno::ENOENT.new path
+      end
+
+      def lookup_parent!(path)
+        node = lookup ::File.dirname expand path
+
+        if node && node.is_a?(Dir)
+          node
+        elsif 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 = 0o777 - backend.umask
+        end
+
+        def lookup(path) # rubocop:disable MethodLength
+          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)
+            end
+          end
+        end
+
+        def add(node)
+          if children.any? {|c| c.name == node.name }
+            raise ArgumentError.new "Node #{path}/#{node.name} already exists."
+          end
+
+          children << node
+          node.added self
+        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 = 0o666 - backend.umask
+        end
+
+        def lookup(_path)
+          nil
+        end
+      end
+    end
+  end
+end