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

rubypath 0.3.2 → 1.0.0

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

@@ -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