file_permissions 0.1.0

data/spec/god_object/posix_mode/special_mode_spec.rb

@@ -0,0 +1,372 @@
+# encoding: UTF-8
+=begin
+Copyright GodObject Team <dev@godobject.net>, 2012-2016
+
+This file is part of FilePermissions.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+=end
+
+module GodObject
+  module FilePermissions
+
+    describe SpecialMode do
+      describe ".build" do
+        it "should return the same object if a SpecialMode is given" do
+          existing_mode = SpecialMode.new(5)
+
+          mode = SpecialMode.build(existing_mode)
+
+          expect(mode).to equal existing_mode
+        end
+
+        it "should create a new instance through parsing if given a String" do
+          argument = 'r-x'
+
+          expect(SpecialMode).to receive(:parse).once.with(argument)
+
+          SpecialMode.build(argument)
+        end
+
+        it "should create a new instance if given something else" do
+          argument = 4
+
+          expect(SpecialMode).to receive(:new).once.with(argument)
+
+          SpecialMode.build(argument)
+        end
+      end
+
+      describe ".parse" do
+        context "given an octal representation" do
+          it "should return an empty set if a 0 is given" do
+            expect(SpecialMode.parse('0')).to eql SpecialMode.new(Set[])
+          end
+
+          it "should return a set including the sticky token if a 1 is given" do
+            expect(SpecialMode.parse('1')).to eql SpecialMode.new(Set[:sticky])
+          end
+
+          it "should return a set including the setgid token if a 2 is given" do
+            expect(SpecialMode.parse('2')).to eql SpecialMode.new(Set[:setgid])
+          end
+
+          it "should return a set including the setgid and sticky tokens if a 3 is given" do
+            expect(SpecialMode.parse('3')).to eql SpecialMode.new(Set[:setgid, :sticky])
+          end
+
+          it "should return a set including the setuid token if a 4 is given" do
+            expect(SpecialMode.parse('4')).to eql SpecialMode.new(Set[:setuid])
+          end
+
+          it "should return a set including the setuid and sticky tokens if a 5 is given" do
+            expect(SpecialMode.parse('5')).to eql SpecialMode.new(Set[:setuid, :sticky])
+          end
+
+          it "should return a set including the setuid and setgid tokens if a 6 is given" do
+            expect(SpecialMode.parse('6')).to eql SpecialMode.new(Set[:setuid, :setgid])
+          end
+
+          it "should return a set including the setuid, setgid and sticky tokens if a 7 is given" do
+            expect(SpecialMode.parse('7')).to eql SpecialMode.new(Set[:setuid, :setgid, :sticky])
+          end
+
+          it "should raise an exception if 8 is given" do
+            expect {
+              SpecialMode.parse('8')
+            }.to raise_error(ParserError, 'Invalid format')
+          end
+        end
+
+        context "representation in symbolic mode" do
+          it "should complain about a short representation" do
+            expect {
+              SpecialMode.parse('st')
+            }.to raise_error(ParserError, 'Invalid format')
+          end
+
+          it "should complain about invalid symbols" do
+            expect {
+              SpecialMode.parse('s-a')
+            }.to raise_error(ParserError, 'Invalid format')
+          end
+
+          it "should complain about invalid order" do
+            expect {
+              SpecialMode.parse('tss')
+            }.to raise_error(ParserError, 'Invalid format')
+          end
+
+          it "should parse the setuid symbol" do
+            result = SpecialMode.parse('s--')
+            expect(result).to eql SpecialMode.new(Set[:setuid])
+          end
+
+          it "should parse the setgid symbol" do
+            result = SpecialMode.parse('-s-')
+            expect(result).to eql SpecialMode.new(Set[:setgid])
+          end
+
+          it "should parse the sticky symbol" do
+            result = SpecialMode.parse('--t')
+            expect(result).to eql SpecialMode.new(Set[:sticky])
+          end
+        end
+      end
+
+      describe ".new" do
+        it "should handle no parameters" do
+          mode = SpecialMode.new
+          expect(mode).to be_a(SpecialMode)
+          expect(mode.setuid?).to eql false
+          expect(mode.setgid?).to eql false
+          expect(mode.sticky?).to eql false
+          expect(mode.to_i).to eql 0
+          expect(mode.to_s).to eql "---"
+          attributes = { setuid: false, setgid: false, sticky: false }
+          expect(mode.state).to eql attributes
+        end
+
+        it "should handle a Set" do
+          mode = SpecialMode.new(Set[:setuid, :sticky])
+
+          expect(mode.state).to eql(setuid: true, setgid: false, sticky: true)
+          expect(mode.setuid?).to eql true
+          expect(mode.setgid?).to eql false
+          expect(mode.sticky?).to eql true
+        end
+
+        it "should handle an array of mode components" do
+          mode = SpecialMode.new(:setuid, :setgid, :sticky)
+          attributes = { setuid: true, setgid: true, sticky: true }
+
+          expect(mode.state).to eql attributes
+        end
+      end
+
+      let(:empty_mode)         { SpecialMode.parse('---') }
+      let(:sticky_mode)        { SpecialMode.parse('--t') }
+      let(:setgid_mode)        { SpecialMode.parse('-s-') }
+      let(:setgid_sticky_mode) { SpecialMode.parse('-st') }
+      let(:setuid_mode)        { SpecialMode.parse('s--') }
+      let(:setuid_sticky_mode) { SpecialMode.parse('s-t') }
+      let(:setuid_setgid_mode) { SpecialMode.parse('ss-') }
+      let(:full_mode)          { SpecialMode.parse('sst') }
+
+      describe "#==" do
+        it "should be true if compare to itself" do
+          expect(empty_mode).to eq(empty_mode)
+        end
+
+        it "should be false if setuid attributes differ" do
+          expect(setuid_sticky_mode).not_to eq(sticky_mode)
+        end
+
+        it "should be false if setgid attributes differ" do
+          expect(setgid_sticky_mode).not_to eq(sticky_mode)
+        end
+
+        it "should be false if sticky attributes differ" do
+          expect(setgid_sticky_mode).not_to eq(setgid_mode)
+        end
+
+        it "should be true if compared to a SpecialMode with same attributes" do
+          expect(empty_mode).to eq(SpecialMode.new)
+        end
+
+        it "should be true if compared to an ACL-like with the same entries?" do
+          other = OpenStruct.new(
+            to_i: 6, configuration: OpenStruct.new(digits: [:setuid, :setgid, :sticky])
+          )
+
+          expect(setuid_setgid_mode).to eq(other)
+        end
+      end
+
+      describe "#eql?" do
+        it "should be true if compare to itself" do
+          expect(SpecialMode.new).to eql SpecialMode.new
+        end
+
+        it "should be false if attributes are the same but class differs" do
+          other = OpenStruct.new(attribute: { setuid: false, setgid: false, sticky: false })
+          expect(SpecialMode.new).not_to eql other
+        end
+      end
+
+      describe "#<=>" do
+        it "should return -1 if the compared SpecialMode has a higher octal representation" do
+          expect(setgid_mode <=> setuid_mode).to eql -1
+        end
+
+        it "should return 1 if the compared SpecialMode has a lower octal representation" do
+          expect(setuid_mode <=> setgid_mode).to eql 1
+        end
+
+        it "should return 0 if the compared SpecialMode has an equal octal representation" do
+          expect(sticky_mode <=> sticky_mode).to eql 0
+        end
+
+        it "should return nil if the compared object is incompatible" do
+          expect(setgid_mode <=> :something).to eql nil
+        end
+      end
+
+      describe "#inspect" do
+        it "should give a decent string representation for debugging" do
+          expect(full_mode.inspect).to eq("#<#{subject.class}: \"sst\">")
+          expect(setuid_setgid_mode.inspect).to eq("#<#{subject.class}: \"ss-\">")
+          expect(setuid_sticky_mode.inspect).to eq("#<#{subject.class}: \"s-t\">")
+          expect(setgid_sticky_mode.inspect).to eq("#<#{subject.class}: \"-st\">")
+          expect(setuid_mode.inspect).to eq("#<#{subject.class}: \"s--\">")
+          expect(setgid_mode.inspect).to eq("#<#{subject.class}: \"-s-\">")
+          expect(sticky_mode.inspect).to eq("#<#{subject.class}: \"--t\">")
+          expect(empty_mode.inspect).to eq("#<#{subject.class}: \"---\">")
+        end
+      end
+
+      describe "#to_s" do
+        it "should represent attributes as string" do
+          expect(full_mode.to_s(:long)).to eq("sst")
+          expect(setuid_setgid_mode.to_s(:long)).to eq("ss-")
+          expect(setuid_sticky_mode.to_s(:long)).to eq("s-t")
+          expect(setgid_sticky_mode.to_s(:long)).to eq("-st")
+          expect(setuid_mode.to_s(:long)).to  eq("s--")
+          expect(setgid_mode.to_s(:long)).to  eq("-s-")
+          expect(sticky_mode.to_s(:long)).to  eq("--t")
+          expect(empty_mode.to_s(:long)).to  eq("---")
+        end
+      end
+
+      describe "#to_i" do
+        it "should represent no attributes in octal" do
+          expect(empty_mode.to_i).to eql 0
+        end
+
+        it "should represent sticky attribute in octal" do
+          expect(sticky_mode.to_i).to eql 1
+        end
+
+        it "should represent setgid attribute in octal" do
+          expect(setgid_mode.to_i).to eql 2
+        end
+
+        it "should represent sticky and setgid attributes in octal" do
+          expect(setgid_sticky_mode.to_i).to eql 3
+        end
+
+        it "should represent setuid attribute in octal" do
+          expect(setuid_mode.to_i).to eql 4
+        end
+
+        it "should represent setuid and sticky attributes in octal" do
+          expect(setuid_sticky_mode.to_i).to eql 5
+        end
+
+        it "should represent setuid and setgid attributes in octal" do
+          expect(setuid_setgid_mode.to_i).to eql 6
+        end
+
+        it "should represent setuid, setgid and sticky attributes in octal" do
+          expect(full_mode.to_i).to eql 7
+        end
+      end    
+      
+      describe "#setuid?" do
+        it "should be true if setuid attribute is set" do
+          expect(setuid_mode.setuid?).to eql true
+        end
+
+        it "should be false if setuid attribute is not set" do
+          expect(setgid_sticky_mode.setuid?).to eql false
+        end
+      end
+
+      describe "#setgid?" do
+        it "should be true if setgid attribute is set" do
+          expect(setgid_sticky_mode.setgid?).to eql true
+        end
+
+        it "should be false if setgid attribute is not set" do
+          expect(setuid_sticky_mode.setgid?).to eql false
+        end
+      end    
+      
+      describe "#sticky?" do
+        it "should be true if sticky attribute is set" do
+          expect(setuid_sticky_mode.sticky?).to eql true
+        end
+
+        it "should be false if sticky attribute is not set" do
+          expect(empty_mode.sticky?).to eql false
+        end
+      end
+
+      describe "#invert" do
+        it "should create a new SpecialMode with all digits inverted" do
+          result = setuid_sticky_mode.invert
+
+          expect(result).not_to equal setuid_sticky_mode
+          expect(result).to eql setgid_mode
+        end
+      end
+
+      describe "#-" do
+        it "should create a new SpecialMode from the first operand without the digits of the second operand" do
+          result = full_mode - setgid_mode
+
+          expect(result).not_to equal full_mode
+          expect(result).not_to equal setgid_mode
+          expect(result).to eql setuid_sticky_mode
+        end
+      end
+
+      [:intersection, :&].each do |method_name|
+        describe "##{method_name}" do
+          it "should create a new SpecialMode with only those digits enabled that are enabled in both operands" do
+            result = setuid_setgid_mode.public_send(method_name, setgid_sticky_mode)
+
+            expect(result).not_to equal setuid_setgid_mode
+            expect(result).not_to equal setgid_sticky_mode
+            expect(result).to eql setgid_mode
+          end
+        end
+      end
+
+      [:union, :|, :+].each do |method_name|
+        describe "##{method_name}" do
+          it "should create a new SpecialMode with all enabled digits of both operands" do
+            result = setuid_mode.public_send(method_name, setgid_mode)
+
+            expect(result).not_to equal setuid_mode
+            expect(result).not_to equal setgid_mode
+            expect(result).to eql setuid_setgid_mode
+          end
+        end
+      end
+
+      [:symmetric_difference, :^].each do |method_name|
+        describe "##{method_name}" do
+          it "should create a new SpecialMode with only those digits enabled that are enabled in only one operand" do
+            result = full_mode.public_send(method_name, sticky_mode)
+
+            expect(result).not_to equal full_mode
+            expect(result).not_to equal sticky_mode
+            expect(result).to eql setuid_setgid_mode
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+=begin
+Copyright GodObject Team <dev@godobject.net>, 2012-2016
+
+This file is part of FilePermissions.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+=end
+
+require 'bundler'
+
+Bundler.setup
+
+unless defined?(Rubinius)
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+end
+
+require 'coveralls'
+
+Coveralls.wear!
+
+require 'rspec'
+require 'pry'
+require 'file_permissions'
+require 'fileutils'
+require 'ostruct'

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: file_permissions
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Oliver Feldt
+- Alexander E. Fischer
+- Axel Sorge
+- Andreas Wurm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bit_set
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  FilePermissions is a Ruby library providing an object representation of the
+  file permission bits in POSIX systems.
+
+  It can handle the generic read, write and execute permissions, as well as
+  the setuid, setgid and sticky flags. Permission sets can be read from file
+  system objects, parsed from typical string representations or simply
+  defined by their numeric representation. They can then be manipulated
+  through binary logic operators and written back to file system objects.
+email:
+- of@godobject.net
+- aef@godobject.net
+- as@godobject.net
+- aw@godobject.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- HISTORY.md
+- LICENSE.md
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- HISTORY.md
+- LICENSE.md
+- README.md
+- Rakefile
+- file_permissions.gemspec
+- lib/file_permissions.rb
+- lib/god_object/file_permissions.rb
+- lib/god_object/file_permissions/complex_mode.rb
+- lib/god_object/file_permissions/exceptions.rb
+- lib/god_object/file_permissions/helper_mixin.rb
+- lib/god_object/file_permissions/mode.rb
+- lib/god_object/file_permissions/mode_mixin.rb
+- lib/god_object/file_permissions/special_mode.rb
+- lib/god_object/file_permissions/version.rb
+- spec/god_object/posix_mode/complex_mode_spec.rb
+- spec/god_object/posix_mode/mode_spec.rb
+- spec/god_object/posix_mode/special_mode_spec.rb
+- spec/spec_helper.rb
+homepage: https://www.godobject.net/
+licenses:
+- ISC
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Representation and manipulation of POSIX system file permissions in Ruby.
+test_files:
+- spec/god_object/posix_mode/complex_mode_spec.rb
+- spec/god_object/posix_mode/mode_spec.rb
+- spec/god_object/posix_mode/special_mode_spec.rb
+- spec/spec_helper.rb
+has_rdoc: yard