RubyGems - rubypath - Versions diffs - 0.3.2 → 1.0.0 - Mend

rubypath 0.3.2 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

checksums.yaml +4 -4
metadata +5 -55
data/CHANGELOG.md +0 -24
data/LICENSE.txt +0 -165
data/README.md +0 -102
data/doc/file.README.html +0 -175
data/lib/rubypath.rb +0 -29
data/lib/rubypath/backend.rb +0 -92
data/lib/rubypath/backend/mock.rb +0 -356
data/lib/rubypath/backend/sys.rb +0 -161
data/lib/rubypath/comparison.rb +0 -19
data/lib/rubypath/construction.rb +0 -109
data/lib/rubypath/dir_operations.rb +0 -160
data/lib/rubypath/extensions.rb +0 -157
data/lib/rubypath/file_operations.rb +0 -192
data/lib/rubypath/file_predicates.rb +0 -32
data/lib/rubypath/identity.rb +0 -59
data/lib/rubypath/io_operations.rb +0 -82
data/lib/rubypath/mock.rb +0 -42
data/lib/rubypath/path_operations.rb +0 -311
data/lib/rubypath/path_predicates.rb +0 -61
data/lib/rubypath/version.rb +0 -11
data/rubypath.gemspec +0 -22
data/spec/README_spec.rb +0 -27
data/spec/rubypath/comparison_spec.rb +0 -77
data/spec/rubypath/construction_spec.rb +0 -101
data/spec/rubypath/dir_operations_spec.rb +0 -225
data/spec/rubypath/extensions_spec.rb +0 -270
data/spec/rubypath/file_operations_spec.rb +0 -428
data/spec/rubypath/file_predicates_spec.rb +0 -66
data/spec/rubypath/identity_spec.rb +0 -21
data/spec/rubypath/io_operations_spec.rb +0 -128
data/spec/rubypath/path_operations_spec.rb +0 -483
data/spec/rubypath/path_predicates_spec.rb +0 -75
data/spec/spec_helper.rb +0 -42
data/spec/support/describe_method.rb +0 -18
data/spec/support/with_backend.rb +0 -37

data/spec/README_spec.rb DELETED

@@ -1,27 +0,0 @@
-require 'spec_helper'
-describe 'README examples' do
-  describe 'Mock FS' do
-    around {|example| Path::Backend.mock(&example) }
-    before do
-      Path.mock do |root, backend|
-        backend.cwd          = '/root'
-        backend.current_user = 'test'
-        backend.homes        = {'test' => '/home/test'}
-        home = root.mkpath('/home/test')
-        home.mkfile('src/test.txt').write 'CONTENT'
-        home.mkfile('src/test.html').write '<html><head><title></title>...'
-      end
-    end
-    it 'should mock all FS' do
-      base = Path('~test').expand
-      expect(base.join(%w(src test.txt)).read).to eq 'CONTENT'
-      files = base.glob('**/*').select{|p| p.file? }
-      expect(files.size).to eq 2
-    end
-  end
-end

data/spec/rubypath/comparison_spec.rb DELETED

@@ -1,77 +0,0 @@
-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 (2)' do
-          res = path.send described_method, Path('/path/to/another/file')
-          expect(res).to be false
-        end
-        it 'should compare clean paths (1)' do
-          res = path.send described_method, Path('/path/to/./file')
-          expect(res).to be true
-        end
-        it 'should compare clean paths (2)' do
-          res = path.send described_method, Path('/path/to/another/../file')
-          expect(res).to be true
-        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
-        it 'should compare clean paths (1)' do
-          res = path.send described_method, '/path/to/./file'
-          expect(res).to be true
-        end
-        it 'should compare clean paths (2)' do
-          res = path.send described_method, '/path/to/another/../file'
-          expect(res).to be true
-        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
-        it 'should compare clean paths (1)' do
-          res = path.send described_method, Pathname.new('/path/to/./file')
-          expect(res).to be true
-        end
-        it 'should compare clean paths (2)' do
-          res = path.send described_method,
-                          Pathname.new('/path/to/another/../file')
-          expect(res).to be true
-        end
-      end
-    end
-  end
-end

data/spec/rubypath/construction_spec.rb DELETED

@@ -1,101 +0,0 @@
-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 DELETED

@@ -1,225 +0,0 @@
-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
-          if defined?(::File::FNM_EXTGLOB)
-            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
-          end
-          it 'should return matching files (IV)' do
-            expect(subject.call('/lib/*.rb')).to match_array %w(/lib/path.rb)
-          end
-        end
-      end
-      shared_examples '#remove_recursive' do
-        context 'on existent file' do
-          before { path.mkfile }
-          it{ expect{ subject }.to change(path, :exist?).from(true).to(false) }
-        end
-        context 'on existent directory' do
-          before { path.mkpath }
-          it{ expect{ subject }.to change(path, :exist?).from(true).to(false) }
-        end
-        context 'on existent directory with children' do
-          before { path.mkfile('subdir/file') }
-          it{ expect{ subject }.to change(path, :exist?).from(true).to(false) }
-        end
-      end
-      describe_method :rmtree, aliases: [:rm_rf] do
-        let(:path) { Path '/path' }
-        subject { path.send(described_method) }
-        context 'on non-existent file' do
-          it { expect{ subject }.to_not raise_error }
-        end
-        it_behaves_like '#remove_recursive'
-      end
-      describe_method :safe_rmtree do
-        let(:path) { Path '/path' }
-        subject { path.send(described_method) }
-        it 'should use #remove_entry_secure' do
-          if backend_type == :sys
-            path.mkfile
-            expect(FileUtils).to receive(:remove_entry_secure).and_call_original
-            subject
-          end
-        end
-        context 'on non-existent file' do
-          it { expect{ subject }.to_not raise_error }
-        end
-        it_behaves_like '#remove_recursive'
-      end
-      describe_method :rmtree!, aliases: [:rm_r] do
-        let(:path) { Path '/path' }
-        subject { path.send(described_method) }
-        context 'on non-existent file' do
-          it { expect{ subject }.to raise_error Errno::ENOENT }
-        end
-        it_behaves_like '#remove_recursive'
-      end
-      describe_method :safe_rmtree! do
-        let(:path) { Path '/path' }
-        subject { path.send(described_method) }
-        it 'should use #remove_entry_secure' do
-          if backend_type == :sys
-            path.mkfile
-            expect(FileUtils).to receive(:remove_entry_secure).and_call_original
-            subject
-          end
-        end
-        context 'on non-existent file' do
-          it { expect{ subject }.to raise_error Errno::ENOENT }
-        end
-        it_behaves_like '#remove_recursive'
-      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 DELETED

@@ -1,270 +0,0 @@
-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