solaris-file 0.3.7 → 0.4.0

data/lib/solaris/file/constants.rb

@@ -0,0 +1,31 @@
+module Solaris
+  module Constants
+    GETACL = 1
+    SETACL = 2
+    GETACLCNT = 3
+    MIN_ACL_ENTRIES = 4
+
+    USER_OBJ      = (0x01)
+    USER          = (0x02)
+    GROUP_OBJ     = (0x04)
+    GROUP         = (0x08)
+    CLASS_OBJ     = (0x10)
+    OTHER_OBJ     = (0x20)
+    ACL_DEFAULT   = (0x1000)
+    DEF_USER_OBJ  = (ACL_DEFAULT | USER_OBJ)
+    DEF_USER      = (ACL_DEFAULT | USER)
+    DEF_GROUP_OBJ = (ACL_DEFAULT | GROUP_OBJ)
+    DEF_GROUP     = (ACL_DEFAULT | GROUP)
+    DEF_CLASS_OBJ = (ACL_DEFAULT | CLASS_OBJ)
+    DEF_OTHER_OBJ = (ACL_DEFAULT | OTHER_OBJ)
+
+    GRP_ERROR       = 1
+    USER_ERROR      = 2
+    OTHER_ERROR     = 3
+    CLASS_ERROR     = 4
+    DUPLICATE_ERROR = 5
+    MISS_ERROR      = 6
+    MEM_ERROR       = 7
+    ENTRY_ERROR     = 8
+  end
+end

data/lib/solaris/file/functions.rb

@@ -0,0 +1,19 @@
+require 'ffi'
+
+module Solaris
+  module Functions
+    extend FFI::Library
+
+    ffi_lib FFI::Library::LIBC
+
+    attach_function :acl, [:string, :int, :int, :pointer], :int
+    attach_function :facl, [:int, :int, :int, :pointer], :int
+    attach_function :resolvepath_c, :resolvepath, [:string, :pointer, :ulong], :int
+
+    ffi_lib :sec
+
+    attach_function :aclcheck, [:pointer, :int, :pointer], :int
+    attach_function :aclfromtext, [:string, :pointer], :pointer
+    attach_function :acltotext, [:pointer, :int], :string
+  end
+end

data/lib/solaris/file/stat.rb

@@ -0,0 +1,16 @@
+class File::Stat
+  alias ftype_orig ftype
+  remove_method :ftype
+
+  def door?
+    mode & 0xF000 == 0xd000
+  end
+
+  def ftype
+    if mode & 0xF000 == 0xd000
+      "door"
+    else
+      ftype_orig
+    end
+  end
+end

data/lib/solaris/file/structs.rb

@@ -0,0 +1,11 @@
+require 'ffi'
+
+module Solaris
+  module Structs
+    class AclEnt < FFI::Struct
+      layout(:a_type, :int, :a_id, :int, :a_perm, :int)
+    end
+
+    ACLStruct = Struct.new('ACLStruct', :acl_type, :acl_id, :acl_perm)
+  end
+end

data/solaris-file.gemspec

@@ -1,34 +1,31 @@
 require 'rubygems'
 
-Gem::Specification.new do |gem|
-  gem.name       = 'solaris-file'
-  gem.version    = '0.3.7'
-  gem.author     = 'Daniel J. Berger'
-  gem.license    = 'Artistic 2.0'
-  gem.email      = 'djberg96@gmail.com'
-  gem.homepage   = 'http://www.rubyforge.org/projects/solarisutils'
-  gem.platform   = Gem::Platform::RUBY
-  gem.summary    = 'ACL and other methods for the File class on Solaris'
-  gem.test_file  = 'test/test_solaris_file.rb'
-  gem.extensions = ['ext/extconf.rb']
-  gem.files      = Dir['**/*'].reject{ |f| f.include?('git') }
+Gem::Specification.new do |spec|
+  spec.name       = 'solaris-file'
+  spec.version    = '0.4.0'
+  spec.author     = 'Daniel J. Berger'
+  spec.license    = 'Artistic 2.0'
+  spec.email      = 'djberg96@gmail.com'
+  spec.homepage   = 'http://www.github.com/djberg96/solaris-file'
+  spec.summary    = 'ACL and other methods for the File class on Solaris'
+  spec.test_file  = 'test/test_solaris_file.rb'
+  spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
 
-  gem.rubyforge_project = 'solarisutils'
+  spec.rubyforge_project = 'solarisutils'
 
-  gem.extra_rdoc_files = [
+  spec.extra_rdoc_files = [
     'README',
     'CHANGES',
     'MANIFEST',
-    'ext/solaris/sfile.c'
   ]
 
-  gem.add_development_dependency('test-unit', '>= 2.1.1')
-  gem.add_development_dependency('sys-filesystem', '>= 0.3.1')
+  spec.add_development_dependency('test-unit', '>= 2.5.0')
+  spec.add_development_dependency('sys-filesystem', '>= 0.3.1')
 
-  gem.description = <<-EOF
+  spec.description = <<-EOF
     The solaris-file library provides Solaris-specific access control
     methods to the File class. It also provides methods for identifying
-    trivial and door files, interfaces for the realpath() and resolvepath()
-    functions, and an overloaded ftype method.
+    trivial and door files, an interfaces for the resolvepath()
+    function, and an overloaded ftype method.
   EOF
 end

data/test/test_solaris_file.rb

@@ -5,10 +5,7 @@
 # via the 'rake test' task. Note that many tests will be skipped unless you're
 # on a UFS filesystem.
 ###############################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
+require 'test-unit'
 require 'solaris/file'
 require 'sys/filesystem'
 
@@ -41,91 +38,133 @@ class TC_Solaris_File < Test::Unit::TestCase
   end
 
   def test_version
-    assert_equal('0.3.7', File::SOLARIS_VERSION)
+    assert_equal('0.4.0', File::SOLARIS_VERSION)
   end
 
   # SINGLETON METHODS
 
-  def test_singleton_acl_read_basic
+  test "acl_read singleton method basic functionality" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
     assert_respond_to(File, :acl_read)
     assert_nothing_raised{ File.acl_read(@@file1) }
   end
 
-  def test_singleton_acl_read
+  test "acl_read singleton method works as expected" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
     assert_nil(File.acl_read(@@file1))
     assert_kind_of(Array, File.acl_read(@@file2))
+    assert_kind_of(Struct::ACLStruct, File.acl_read(@@file2).first)
   end
 
-  def test_singleton_acl_read_expected_errors
-    assert_raise(Errno::ENOENT){ File.acl_read('bogus') }
-    assert_raise(ArgumentError){ File.acl_read('bogus' * 500) }
+  test "acl_read singleton method returns expected struct values" do
+    struct = File.acl_read(@@file2).first
+    assert_equal('user', struct.acl_type)
+    assert_equal(100, struct.acl_id)
+    assert_equal(6, struct.acl_perm)
+  end
+
+  test "acl_read singleton method requires a single argument" do
     assert_raise(ArgumentError){ File.acl_read }
+    assert_raise(ArgumentError){ File.acl_read(@@file1, @@file2) }
+  end
+
+  test "acl_read singleton method raises an error if the file is not found" do
+    assert_raise(Errno::ENOENT){ File.acl_read('bogus') }
+  end
+
+  test "acl_read singleton method requires a string argument" do
     assert_raise(TypeError){ File.acl_read(1) }
   end
 
-  def test_singleton_acl_read_text_basic
+  test "acl_read_text singleton method basic functionality" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
     assert_respond_to(File, :acl_read_text)
     assert_nothing_raised{ File.acl_read_text(@@file1) }
   end
 
-  def test_singleton_acl_read_text
+  test "acl_read_text singleton method returns expected type of value" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
     assert_nil(File.acl_read_text(@@file1))
-    assert_kind_of(String,File.acl_read_text(@@file2))
+    assert_kind_of(String, File.acl_read_text(@@file2))
+    assert_equal(@@acl_text, File.acl_read_text(@@file2))
   end
 
-  def test_singleton_acl_read_text_expected_errors
-    assert_raise(Errno::ENOENT){ File.acl_read_text('bogus') }
+  test "acl_read_text singleton method requires a single argument only" do
     assert_raise(ArgumentError){ File.acl_read_text }
+    assert_raise(ArgumentError){ File.acl_read_text(@@file1, @@file2) }
+  end
+
+  test "acl_read_text singleton method raises an error if the argument is invalid" do
+    assert_raise(Errno::ENOENT){ File.acl_read_text('bogus') }
+  end
+
+  test "acl_read_text singleton method requires a string argument" do
     assert_raise(TypeError){ File.acl_read_text(1) }
   end
 
-  def test_singleton_acl_write_text
+  test "acl_write_text singleton method basic functionality" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
-    acl_text = 'user::rw-,group::r--,mask:r--,other:---'
+    acl_text = 'user::rw-,group::rw-,mask:r--,other:---'
     assert_respond_to(File, :acl_write_text)
     assert_nothing_raised{ File.acl_write_text(@@file1, acl_text) }
+    assert_kind_of(String, File.acl_write_text(@@file1, acl_text))
+  end
+
+  test "acl_write_text singleton method works as expected" do
+    acl_text = 'user::rw-,group::rw-,mask:r--,other:---'
+    assert_equal(acl_text, File.acl_write_text(@@file1, acl_text))
+    #assert_equal(acl_text, File.acl_read_text(@@file1))
   end
 
-  def test_singleton_acl_write_text_expected_errors
-    assert_raise(File::SolarisError){ File.acl_write_text(@@file1, 'bogus') }
+  test "acl_write_text singleton method if text is invalid" do
+    assert_raise(ArgumentError){ File.acl_write_text(@@file1, 'bogus') }
+    assert_raise_message('invalid ACL text'){ File.acl_write_text(@@file1, 'bogus') }
   end
 
-  def test_singleton_acl_trivial_basic
+  test "trivial? singleton method basic functionality" do
     assert_respond_to(File, :trivial?)
     assert_nothing_raised{ File.trivial?(@@file1) }
     assert_boolean(File.trivial?(@@file1))
   end
 
-  def test_singleton_acl_trivial
+  test "trivial? singleton method returns the expected value" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
     assert_true(File.trivial?(@@file1))
     assert_false(File.trivial?(@@file2))
   end
 
-  def test_singleton_acl_trivial_expected_errors
+  test "trivial? singleton method raises an error if the argument is invalid" do
     assert_raise(Errno::ENOENT){ File.trivial?('bogus') }
-    assert_raise(ArgumentError){ File.trivial?('bogus' * 500) }
+    assert_raise(Errno::ENAMETOOLONG){ File.trivial?('bogus' * 500) }
+  end
+
+  test "trivial? singleton method requires a single string argument" do
     assert_raise(ArgumentError){ File.trivial? }
     assert_raise(TypeError){ File.trivial?(1) }
   end
 
-  def test_singleton_acl_count
+  test "acl_count singleton method basic functionality" do
     assert_respond_to(File, :acl_count)
     assert_nothing_raised{ File.acl_count(@@file1) }
     assert_kind_of(Fixnum, File.acl_count(@@file1))
   end
 
-  def test_singleton_acl_count_expected_errors
+  test "acl_count singleton method returns the expected value" do
+    assert_equal(0, File.acl_count(@@file1))
+    assert_equal(6, File.acl_count(@@file2))
+  end
+
+  test "acl_count singleton method raises an error if the argument is invalid" do
     assert_raise(Errno::ENOENT){ File.acl_count('bogus') }
-    assert_raise(ArgumentError){ File.acl_count('bogus' * 500) }
+    assert_raise(Errno::ENAMETOOLONG){ File.acl_count('bogus' * 500) }
+  end
+
+  test "acl_count singleton method requires a single string argument" do
     assert_raise(ArgumentError){ File.acl_count }
     assert_raise(TypeError){ File.acl_count(1) }
   end
 
+=begin
   def test_singleton_realpath_basic
     assert_respond_to(File, :realpath)
     assert_nothing_raised{ File.realpath(@dir) }
@@ -145,127 +184,154 @@ class TC_Solaris_File < Test::Unit::TestCase
     assert_raise(ArgumentError){ File.realpath }
     assert_raise(TypeError){ File.realpath(1) }
   end
+=end
 
-  def test_singleton_resolvepath_basic
+  test "resolvepath singleton method basic functionality" do
     assert_respond_to(File, :resolvepath)
     assert_nothing_raised{ File.resolvepath(@dir) }
     assert_kind_of(String, File.resolvepath(@dir))
   end
 
-  def test_singleton_resolvepath
+  test "resolvepath singleton method returns the expected value" do
     assert_equal(@dir, File.resolvepath(@dir))
     assert_equal("../examples", File.resolvepath("../examples"))
   end
 
-  def test_singleton_resolvepath_expected_errors
+  test "resolvepath singleton method raises an error if the argument is invalid" do
     assert_raise(Errno::ENOENT){ File.resolvepath('bogus') }
+  end
+
+  test "resolvepath requires a single string argument" do
     assert_raise(ArgumentError){ File.resolvepath }
     assert_raise(TypeError){ File.resolvepath(1) }
   end
 
-  def test_singleton_is_door_basic
+  test "door? singleton method basic functionality" do
     assert_respond_to(File, :door?)
     assert_nothing_raised{ File.door?(@door) }
     assert_boolean(File.door?(@door))
   end
-   
-  def test_singleton_is_door
+
+  test "door? singleton method returns the expected result" do
     assert_true(File.door?(@door))
     assert_false(File.door?(Dir.pwd))
   end
 
-  def test_singleton_is_door_expected_errors
+  test "door? singleton method raises an error if the argument is invalid" do
     assert_raise(Errno::ENOENT){ File.door?('bogus') }
+  end
+
+  test "door? singleton method requires a single string argument" do
     assert_raise(ArgumentError){ File.door? }
     assert_raise(TypeError){ File.door?(1) }
   end
 
-  def test_singleton_ftype_basic
+  test "ftype singleton method is still defined" do
     assert_respond_to(File, :ftype)
   end
 
-  def test_singleton_ftype
+  test "overridden ftype singleton method returns expected value" do
     assert_equal('door', File.ftype(@door))
     assert_equal('directory', File.ftype(Dir.pwd))
   end
 
-  def test_singleton_ftype_expected_errors
+  test "ftype singleton method raises an error if the argument is invalid" do
     assert_raise(Errno::ENOENT){ File.ftype('bogus') }
+  end
+
+  test "ftype singleton method requires a single string argument" do
     assert_raise(ArgumentError){ File.ftype }
     assert_raise(TypeError){ File.ftype(1) }
   end
 
   # INSTANCE METHODS
 
-  def test_instance_acl_basic
+  test "acl_read instance method basic functionality" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
     assert_respond_to(@handle1, :acl_read)
     assert_nothing_raised{ @handle1.acl_read }
   end
 
-  def test_instance_acl
+  test "acl_read instance method works as expected" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
     assert_nil(@handle1.acl_read)
     assert_kind_of(Array, @handle2.acl_read)
     assert_kind_of(Struct::ACLStruct, @handle2.acl_read.first)
   end
 
-  def test_instance_acl_read_text_basic
+  test "acl_read instance method does not accept any arguments" do
+    assert_raise(ArgumentError){ @handle1.acl_read('test.txt') }
+  end
+
+  test "acl_read_text instance method dbasic functionality" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
     assert_respond_to(@handle1, :acl_read_text)
     assert_nothing_raised{ @handle1.acl_read_text }
   end
 
-  def test_instance_acl_read_text
+  test "acl_read_text instance method returns expected value" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
     assert_nil(@handle1.acl_read_text)
     assert_kind_of(String, @handle2.acl_read_text)
   end
 
-  def test_instance_acl_write_text
+  test "acl_write_text instance method basic functionality" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
     acl_text = 'user::rw-,group::r--,mask:r--,other:---'
     assert_respond_to(@handle2, :acl_write_text)
     assert_nothing_raised{ @handle2.acl_write_text(acl_text) }
   end
 
-  def test_instance_acl_write_text_expected_errors
-    assert_raise(File::SolarisError){ @handle2.acl_write_text('bogus') }
+  test "acl_write_text instance method requires a single string argument" do
     assert_raise(ArgumentError){ @handle2.acl_write_text }
     assert_raise(TypeError){ @handle2.acl_write_text(1) }
   end
 
-  def test_instance_acl_trivial_basic
+  test "acl_write_text instance method requires a valid acl string" do
+    assert_raise(ArgumentError){ @handle2.acl_write_text('bogus') }
+  end
+
+  test "trivial? instance method basic functionality" do
     assert_respond_to(@handle1, :trivial?)
     assert_nothing_raised{ @handle1.trivial? }
     assert_boolean(@handle1.trivial?)
   end
 
-  def test_instance_acl_trivial
+  test "trivial? instance method returns the expected value" do
     assert_true(@handle1.trivial?)
     assert_false(@handle2.trivial?)
   end
 
-  def test_instance_acl_count_basic
+  test "acl_count instance method basic functionality" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
     assert_respond_to(@handle1, :acl_count)
     assert_nothing_raised{ @handle1.acl_count }
     assert_kind_of(Fixnum, @handle1.acl_count)
   end
 
-  def test_instance_acl_count
+  test "acl_count instance method returns the expected value" do
     omit_unless(@@ufs, 'skipped on non-ufs filesystem')
     assert_equal(0, @handle1.acl_count)
     assert_equal(6, @handle2.acl_count)
   end
 
-  def test_stat_door
+  test "door? instance method basic functionality" do
     assert_respond_to(@stat, :door?)
+    assert_nothing_raised{ @stat.door? }
+    assert_boolean(@stat.door?)
+  end
+
+  test "door? instance method returns the expected value" do
     assert_true(@stat.door?)
   end
 
-  def test_stat_ftype
+  test "ftype instance method basic functionality" do
     assert_respond_to(@stat, :ftype)
+    assert_nothing_raised{ @stat.ftype }
+    assert_kind_of(String, @stat.ftype)
+  end
+
+  test "ftype instance method returns the expected value" do
     assert_equal('door', @stat.ftype)
   end