rubypath 0.1.0

data/lib/rubypath.rb

@@ -0,0 +1,28 @@
+require 'rubypath/version'
+
+#
+#
+#
+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/rubypath.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rubypath/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rubypath"
+  spec.version       = Path::VERSION
+  spec.authors       = ["Jan Graichen"]
+  spec.email         = ["jg@altimos.de"]
+  spec.description   = %q{Path library incorporating File, Dir, Pathname, IO methods as well as a virtual mock filesystem.}
+  spec.summary       = %q{Path library incorporating File, Dir, Pathname, IO methods as well as a virtual mock filesystem.}
+  spec.homepage      = "https://github.com/jgraichen/rubypath"
+  spec.license       = "LGPLv3"
+
+  spec.files         = Dir['**/*'].grep(%r{^((bin|lib|test|spec|features)/|.*\.gemspec|.*LICENSE.*|.*README.*|.*CHANGELOG.*)})
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+end

data/spec/rubypath/comparison_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Path do
+  describe 'Comparison' do
+    let(:path) { Path.new '/path/to/file' }
+
+    describe_method :eql?, aliases: [:==] do
+      context 'with Path object' do
+        it 'should compare paths (1)' do
+          res = path.send described_method, Path('/path/to/file')
+          expect(res).to be true
+        end
+
+        it 'should compare paths (1)' do
+          res = path.send described_method, Path('/path/to/another/file')
+          expect(res).to be false
+        end
+      end
+
+      context 'with String object' do
+        it 'should compare paths (1)' do
+          res = path.send described_method, '/path/to/file'
+          expect(res).to be true
+        end
+
+        it 'should compare paths (1)' do
+          res = path.send described_method, '/path/to/another/file'
+          expect(res).to be false
+        end
+      end
+
+      context 'with Pathname object' do
+        it 'should compare paths (1)' do
+          res = path.send described_method, Pathname.new('/path/to/file')
+          expect(res).to be true
+        end
+
+        it 'should compare paths (1)' do
+          res = path.send described_method,
+                          Pathname.new('/path/to/another/file')
+          expect(res).to be false
+        end
+      end
+    end
+  end
+end

data/spec/rubypath/construction_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Path do
+  describe 'Construction' do
+    let(:str)  { '/path/to/file' }
+    let(:args) { [str] }
+    let(:path) { described_class.new(*args) }
+    subject { path }
+
+    describe_method :path, aliases: [:to_path, :to_s] do
+      subject { path.send described_method }
+
+      it { should eq str }
+
+      # Should not return same object as internal variable
+      # to avoid in-place modifications like
+      # `Path.new('/abc').path.delete!('abc')`
+      it { should_not equal path.send(:instance_variable_get, :@path) }
+    end
+
+    describe '#initialize' do
+      context 'w/o args' do
+        let(:args) { %w() }
+        it { expect(subject.path).to eq '' }
+        it { should be_a Path }
+      end
+
+      context 'with multiple strings' do
+        let(:args) { %w(path to a file.txt) }
+        it { expect(subject.path).to eq 'path/to/a/file.txt' }
+        it { should be_a Path }
+      end
+
+      context 'with Pathname' do
+        let(:args) { [Pathname.new('path/to/dir'), 'file.txt'] }
+        it { expect(subject.path).to eq 'path/to/dir/file.txt' }
+        it { should be_a Path }
+      end
+
+      context 'with Numerals' do
+        let(:args) { ['path', 5, 'to', 4.5, 'file.txt'] }
+        it { expect(subject.path).to eq 'path/5/to/4.5/file.txt' }
+        it { should be_a Path }
+      end
+    end
+
+    describe 'class' do
+      describe '#new' do
+        context 'with Path as argument' do
+          let(:args) { [Path.new('/abc')] }
+          it('should return same object') { should equal args.first }
+        end
+
+        context 'w/o args' do
+          let(:args) { Array.new }
+          it('should return Path::EMPTY') { should equal Path::EMPTY }
+        end
+      end
+
+      describe '#like?' do
+        subject { Path.like? obj }
+
+        context 'positive list' do
+          {
+            'Path' => Path.new('/path/to/file.ext'),
+            'Pathname' => Pathname.new('/path/to/file.ext'),
+            'String' => '/path/to/file.ext',
+            '#to_path' => Class.new{ def to_path; '/path/to/file.ext' end }.new,
+            '#path' => Class.new{ def path; '/path/to/file.ext' end }.new
+          }.each do |name, example|
+            let(:obj) { example.dup }
+            it("should accept #{name}") { should be true }
+          end
+        end
+      end
+
+      describe '#like_path' do
+        subject { Path.like_path obj }
+
+        context 'positive list' do
+          {
+            'Path' => Path.new('/path/to/file.ext'),
+            'Pathname' => Pathname.new('/path/to/file.ext'),
+            'String' => '/path/to/file.ext',
+            '#to_path' => Class.new{ def to_path; '/path/to/file.ext' end }.new,
+            '#path' => Class.new{ def path; '/path/to/file.ext' end }.new
+          }.each do |name, example|
+            let(:obj) { example.dup }
+            it("should get path from #{name}") { should eq '/path/to/file.ext' }
+          end
+        end
+      end
+
+      describe '#to_proc' do
+        it 'should allow to use Path as block' do
+          expect(%w(path1 path2).map(&Path)).to eq [Path('path1'), Path('path2')]
+        end
+      end
+    end
+  end
+end

data/spec/rubypath/dir_operations_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe Path do
+  describe 'Directory Operations' do
+    with_backends :mock, :sys do
+      describe 'class' do
+        describe_method :glob do
+          before do
+            Path.mock do |root|
+              root.mkfile '/file.txt'
+              root.mkfile '/lib/path.rb'
+              root.mkfile '/lib/path/dir.rb'
+              root.mkfile '/lib/path/file.rb'
+              root.mkfile '/lib/path/ext.rb'
+            end
+          end
+          subject { ->(*args){ Path.glob(*args) } }
+
+          it 'should return matching files (I)' do
+            expect(subject.call('/*')).to match_array %w(/file.txt /lib)
+          end
+
+          it 'should return matching files (II)' do
+            expect(subject.call('/**/*.rb')).to match_array \
+              %w(/lib/path.rb /lib/path/dir.rb
+                 /lib/path/file.rb /lib/path/ext.rb)
+          end
+
+          it 'should return matching files (III)' do
+            expect(subject.call('/**/{dir,ext}.rb')).to match_array \
+              %w(/lib/path/dir.rb /lib/path/ext.rb)
+          end
+
+          it 'should return matching files (IV)' do
+            expect(subject.call('/lib/*.rb')).to match_array %w(/lib/path.rb)
+          end
+        end
+      end
+
+      describe '#glob' do
+        it 'should delegate to class#glob' do
+          expect(Path).to receive(:glob)
+            .with('/abc\[\]/.\*\{\}/file/**/{a,b}.rb', 10).and_return([])
+
+          Path('/abc[]/.*{}/file').glob('**/{a,b}.rb', 10)
+        end
+      end
+
+      describe '#mkdir' do
+        context 'w/o arg' do
+          let(:dir) { Path '/dir' }
+          before { expect(dir).to_not be_existent }
+          subject { dir.mkdir }
+
+          it 'should create directory' do
+            expect(subject).to be_directory
+          end
+
+          it 'should return path to directory' do
+            expect(subject).to eq '/dir'
+          end
+
+          it { should be_a Path }
+
+          context 'in non-existent parent directory' do
+            let(:dir) { Path '/non-ext/dir' }
+            before { expect(dir).to_not be_existent }
+            before { expect(dir.parent).to_not be_existent }
+            subject { dir.mkdir }
+
+            it 'should raise some error' do
+              expect{ subject }.to raise_error(
+                Errno::ENOENT, 'No such file or directory - /non-ext/dir')
+            end
+          end
+        end
+
+        context 'with arg' do
+          let(:dir)  { Path '/' }
+          let(:args) { ['fuu'] }
+          before { expect(dir.join(*args)).to_not be_existent }
+          subject { dir.mkdir(*args) }
+
+          it 'should create directory' do
+            expect(subject).to be_directory
+          end
+
+          it 'should return path to directory' do
+            expect(subject).to eq '/fuu'
+          end
+
+          it { should be_a Path }
+        end
+      end
+
+      describe_method :mkpath, aliases: [:mkdir_p] do
+        let(:dir) { Path '/path/to/dir' }
+        before { expect(dir).to_not be_existent }
+        before { expect(dir.parent).to_not be_existent }
+        subject { dir.send(described_method) }
+
+        it 'should create directories' do
+          expect(subject).to be_directory
+        end
+
+        it 'should return path to directory' do
+          expect(subject).to eq '/path/to/dir'
+        end
+
+        it { should be_a Path }
+      end
+
+      describe_method :entries do
+        let(:path) { Path '/' }
+        let(:args) { Array.new }
+        subject { path.send described_method, *args }
+
+        context 'with directory with children' do
+          before do
+            path.touch 'file.a'
+            path.touch 'file.b'
+            path.mkdir 'dir.a'
+            path.mkdir 'dir.b'
+          end
+
+          it 'should list of entries' do
+            expect(subject).to match_array %w(.. . file.a file.b dir.a dir.b)
+          end
+
+          it 'should return list of Path objects' do
+            subject.each{|e| expect(e).to be_a Path }
+          end
+        end
+
+        context 'with non-existent directory' do
+          let(:path) { Path '/non-existent-dir' }
+
+          it 'should raise error' do
+            expect{ subject }.to raise_error(
+              Errno::ENOENT, 'No such file or directory - /non-existent-dir')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rubypath/extensions_spec.rb

@@ -0,0 +1,270 @@
+require 'spec_helper'
+
+describe Path do
+  describe 'Extensions' do
+    let(:path) { Path '/path/to/template.de.html.slim' }
+    let(:dotfile) { Path '/path/to/.dotfile' }
+    let(:dotfile_ext) { Path '/path/to/.dotfile.en.sh' }
+
+    describe_method :extensions, aliases: [:exts] do
+      subject { path.send described_method }
+
+      it 'should return all file extensions' do
+        should eq %w(de html slim)
+      end
+
+      context 'dotfile w/o ext' do
+        let(:path) { dotfile }
+
+        it 'should not return dotfile name as extension' do
+          should eq Array.new
+        end
+      end
+
+      context 'dotfile with ext' do
+        let(:path) { dotfile_ext }
+
+        it 'should only return dotfile extension' do
+          should eq %w(en sh)
+        end
+      end
+    end
+
+    describe '#extname' do
+      subject { path.extname }
+
+      it 'should return file extensions including dot' do
+        should eq '.slim'
+      end
+
+      context 'dotfile w/o ext' do
+        let(:path) { dotfile }
+
+        it 'should not return dotfile name as extension' do
+          should eq ''
+        end
+      end
+
+      context 'dotfile with ext' do
+        let(:path) { dotfile_ext }
+
+        it 'should only return dotfile extension' do
+          should eq '.sh'
+        end
+      end
+    end
+
+    describe '#pure_name' do
+      subject { path.pure_name }
+
+      it 'should return file name without extensions' do
+        should eq 'template'
+      end
+
+      context 'dotfile w/o ext' do
+        let(:path) { dotfile }
+
+        it 'should return dotfile name' do
+          should eq '.dotfile'
+        end
+      end
+
+      context 'dotfile with ext' do
+        let(:path) { dotfile_ext }
+
+        it 'should return dotfile name w/o exts' do
+          should eq '.dotfile'
+        end
+      end
+    end
+
+    describe_method :extension, aliases: [:ext] do
+      subject { path.send described_method }
+
+      it 'should return last file extensions' do
+        should eq 'slim'
+      end
+    end
+
+    describe_method :replace_extensions do
+      let(:path) { Path "#{base}file#{exts}" }
+
+      shared_examples 'extensions replacement' do
+        context 'with array' do
+          subject { path.send described_method, %w(en txt) }
+
+          it 'should replace all file extensions' do
+            should eq "#{base}file.en.txt"
+          end
+
+          it { should be_a Path }
+        end
+
+        context 'with multiple arguments' do
+          subject { path.send described_method, *%w(en txt) }
+
+          it 'should replace all file extensions' do
+            should eq "#{base}file.en.txt"
+          end
+
+          it { should be_a Path }
+        end
+      end
+
+      shared_examples 'w/o ext' do
+        let(:exts)  { '' }
+        it_behaves_like 'extensions replacement'
+
+        context 'with replacement hash' do
+          subject{ path.send(described_method, 'txt' => 'html') }
+
+          it 'should replace all file extensions' do
+            should eq "#{base}file"
+          end
+
+          it { should be_a Path }
+        end
+      end
+
+      shared_examples 'with single ext' do
+        let(:exts)  { '.txt' }
+        it_behaves_like 'extensions replacement'
+
+        context 'with replacement hash' do
+          subject { path.send(described_method, 'txt' => 'html') }
+
+          it 'should replace all file extensions' do
+            should eq "#{base}file.html"
+          end
+
+          it { should be_a Path }
+        end
+      end
+
+      shared_examples 'with multiple ext' do
+        let(:exts)  { '.en.html.slim' }
+        it_behaves_like 'extensions replacement'
+
+        context 'with replacement hash' do
+          subject { path.send(described_method, 'en' => 'de') }
+
+          it 'should replace all file extensions' do
+            should eq "#{base}file.de.html.slim"
+          end
+
+          it { should be_a Path }
+        end
+      end
+
+      context 'with path' do
+        let(:base) { '/path/to/' }
+        it_behaves_like 'w/o ext'
+        it_behaves_like 'with single ext'
+        it_behaves_like 'with multiple ext'
+      end
+
+      context 'with filename only' do
+        let(:base) { '' }
+        it_behaves_like 'w/o ext'
+        it_behaves_like 'with single ext'
+        it_behaves_like 'with multiple ext'
+      end
+
+      context 'with relative file path (I)' do
+        let(:base) { './' }
+        it_behaves_like 'w/o ext'
+        it_behaves_like 'with single ext'
+        it_behaves_like 'with multiple ext'
+      end
+
+      context 'with relative file path (II)' do
+        let(:base) { 'path/' }
+        it_behaves_like 'w/o ext'
+        it_behaves_like 'with single ext'
+        it_behaves_like 'with multiple ext'
+      end
+    end
+
+    describe_method :replace_extension do
+      let(:path) { Path "#{base}#{file}#{ext}" }
+
+      shared_examples 'extension replacement' do
+        context 'with array' do
+          subject { path.send described_method, %w(mobile txt) }
+
+          it 'should replace last file extensions' do
+            should eq "#{base}#{file}.mobile.txt"
+          end
+
+          it { should be_a Path }
+        end
+
+        context 'with multiple arguments' do
+          subject { path.send described_method, *%w(mobile txt) }
+
+          it 'should replace last file extensions' do
+            should eq "#{base}#{file}.mobile.txt"
+          end
+
+          it { should be_a Path }
+        end
+
+        context 'with single string' do
+          subject { path.send described_method, 'haml' }
+
+          it 'should replace last file extensions' do
+            should eq "#{base}#{file}.haml"
+          end
+
+          it { should be_a Path }
+        end
+      end
+
+      shared_examples 'w/o ext' do
+        let(:file) { 'file' }
+        let(:ext)  { '' }
+        it_behaves_like 'extension replacement'
+      end
+
+      shared_examples 'with single ext' do
+        let(:file) { 'file' }
+        let(:ext)  { '.txt' }
+        it_behaves_like 'extension replacement'
+      end
+
+      shared_examples 'with multiple ext' do
+        let(:file) { 'file.de' }
+        let(:ext)  { '.txt' }
+        it_behaves_like 'extension replacement'
+      end
+
+      context 'on path file' do
+        let(:base) { '/path/to/file/' }
+        it_behaves_like 'w/o ext'
+        it_behaves_like 'with single ext'
+        it_behaves_like 'with multiple ext'
+      end
+
+      context 'on relative path file' do
+        let(:base) { 'to/file/' }
+        it_behaves_like 'w/o ext'
+        it_behaves_like 'with single ext'
+        it_behaves_like 'with multiple ext'
+      end
+
+      context 'on relative root path file' do
+        let(:base) { './' }
+        it_behaves_like 'w/o ext'
+        it_behaves_like 'with single ext'
+        it_behaves_like 'with multiple ext'
+      end
+
+      context 'on filename only' do
+        let(:base) { '' }
+        it_behaves_like 'w/o ext'
+        it_behaves_like 'with single ext'
+        it_behaves_like 'with multiple ext'
+      end
+    end
+  end
+end