sys-admin 1.4.4 → 1.4.5

data/CHANGES

@@ -1,3 +1,13 @@
+== 1.4.5 - 1-Mar-2009
+* Added the User#groups method. This returns an array of groups that the
+  user belongs to. Suggestion inspired by Gonzalo Garramuno.
+* Changed User#class to User#access_class to avoid conflicts with the
+  Ruby core Object method. 
+* Added more tests and renamed the test files.
+* Removed an unnecessary function call where a platform might try to
+  get lastlog information even if the lastlog.h or utmp.h headers couldn't
+  be found.
+
 == 1.4.4 - 19-Nov-2008
 * Added the User#uid method for MS Windows (which is just the user's relative
   identifier).

data/README

@@ -1,8 +1,11 @@
 == Description
-   The sys-admin package is a unified, cross platform replacement for the
+   The sys-admin library is a unified, cross platform replacement for the
    Etc module.
    
 == Installation
+= Typical Gem Installation
+   gem install sys-admin
+= Local installation
    rake test (optional)
    rake install
 
@@ -167,6 +170,7 @@ Admin::Error < StandardError
    * Admin.delete_global_group
 
    Make the User and Group objects comparable.
+   Support BSD.
 
 == Known Bugs
    None that I'm aware of. If you find any, please log them on the project
@@ -176,7 +180,7 @@ Admin::Error < StandardError
    Ruby's
 
 == Copyright
-   (C) 2005-2008, Daniel J. Berger
+   (C) 2005-2009, Daniel J. Berger
    All Rights Reserved
 
 == Author

data/Rakefile

@@ -52,5 +52,10 @@ Rake::TestTask.new("test") do |t|
       t.libs << 'ext'
       t.libs.delete('lib')
    end
-   t.test_files = FileList['test/tc_admin.rb']
+   t.libs << 'test'
+   t.test_files = FileList['test/test_sys_admin.rb']
+end
+
+task :test do
+   Rake.application[:clean].execute
 end

data/ext/sys/admin.c

@@ -265,6 +265,37 @@ static VALUE admin_users(VALUE klass){
    );
 }
 
+/* call-seq:
+ *    User#groups # => ['staff', 'admin', ...]
+ *
+ * Returns an array of groups the user belongs to.
+ */
+static VALUE user_groups(VALUE self){
+   VALUE v_groups, v_group, v_users, v_group_name, v_name, v_result;
+   int i;
+
+   v_name   = rb_funcall(self, rb_intern("name"), 0, 0);
+   v_result = rb_ary_new();
+   v_groups = admin_groups(self);
+
+   /* Iterate over each group, checking its members. If the members includes
+    * the user name, we have a match.
+    */
+   if(!NIL_P(v_groups)){
+      for(i = 0; i < RARRAY(v_groups)->len; i++){
+         v_group = RARRAY(v_groups)->ptr[i];
+         v_users = rb_funcall(v_group, rb_intern("members"), 0, 0);
+
+         if(RTEST(rb_funcall(v_users, rb_intern("include?"), 1, v_name))){
+            v_group_name = rb_funcall(v_group, rb_intern("name"), 0, 0);
+            rb_ary_push(v_result, v_group_name);
+         }
+      }
+   }
+
+   return v_result;
+}
+
 /*
  * The Sys::Admin class encapsulates typical operations surrounding the query
  * of user and group information.
@@ -296,6 +327,7 @@ void Init_admin(){
 
    /* Instance Methods */
    rb_define_method(cUser, "initialize", user_init, 0);
+   rb_define_method(cUser, "groups", user_groups, 0);
    rb_define_method(cGroup,"initialize", group_init, 0);
 
    /* User Attributes */
@@ -328,7 +360,7 @@ void Init_admin(){
    rb_define_attr(cUser, "age", 1, 1);
 
    /* The user's access class */
-   rb_define_attr(cUser, "class", 1, 1);
+   rb_define_attr(cUser, "access_class", 1, 1);
 
    /* Another comment field. Rarely used. */
    rb_define_attr(cUser, "comment", 1, 1);
@@ -336,7 +368,7 @@ void Init_admin(){
    /* Account expiration date */
    rb_define_attr(cUser, "expire", 1, 1);
 
-   /* Next data a password change will be needed */
+   /* Next date a password change will be needed */
    rb_define_attr(cUser, "change", 1, 1);
 
    /* The last time the user logged in */
@@ -364,6 +396,6 @@ void Init_admin(){
 
    /* Constants */
 
-   /* 1.4.4: The version of this library */
+   /* 1.4.5: The version of this library */
    rb_define_const(cAdmin, "VERSION", rb_str_new2(SYS_ADMIN_VERSION));
 }

data/ext/sys/admin.h

@@ -8,7 +8,7 @@
 #include <errno.h>
 #include <string.h>
 
-#define SYS_ADMIN_VERSION "1.4.4"
+#define SYS_ADMIN_VERSION "1.4.5"
 
 #ifdef HAVE_LASTLOG_H
 #include <lastlog.h>
@@ -226,7 +226,7 @@ static VALUE get_user(struct passwd* pwd){
 #endif
 
 #ifdef HAVE_ST_PW_CLASS
-   rb_iv_set(v_user, "@class", rb_str_new2(pwd->pw_class));
+   rb_iv_set(v_user, "@access_class", rb_str_new2(pwd->pw_class));
 #endif
 
 #ifdef HAVE_ST_PW_EXPIRE
@@ -237,8 +237,9 @@ static VALUE get_user(struct passwd* pwd){
    rb_iv_set(v_user, "@change", rb_time_new(pwd->pw_change, 0));
 #endif
 
-   /* Get the lastlog info for the given user */
+#if defined(HAVE_LASTLOG_H) || defined(HAVE_UTMP_H)
    get_lastlog_info(pwd, v_user);
+#endif
 
    return v_user;
 }
@@ -313,7 +314,7 @@ void get_user_from_value(VALUE v_user, struct passwd* pwd){
 #endif
 
 #ifdef HAVE_ST_PW_CLASS
-   VALUE v_class = rb_iv_get(v_user, "@class");
+   VALUE v_class = rb_iv_get(v_user, "@access_class");
    if(!NIL_P(v_class)){
       SafeStringValue(v_class);
       pwd->pw_class = StringValuePtr(v_class);
@@ -408,6 +409,9 @@ void get_group_from_value(VALUE v_group, struct group* grp){
  * :no-doc:
  *
  * Helper function that gets lastlog information for the User object.
+ *--
+ * Note that even if the platform supports lastlog information, it can
+ * still be empty or nil.
  */
 int get_lastlog_info(struct passwd* pwd, VALUE v_user){
    int fd;

data/test/{tc_admin.rb → test_sys_admin.rb}

@@ -1,14 +1,21 @@
 ###############################################################################
-# tc_admin.rb
+# test_sys_admin.rb
 #
 # This exists mostly for the sake of the gemspec, so that it calls the right
 # test suite based on the platform.
 ###############################################################################
-$LOAD_PATH.unshift Dir.pwd
-$LOAD_PATH.unshift File.join(Dir.pwd, 'test')
+require 'rubygems'
+gem 'test-unit'
+require 'test/unit'
 
 if File::ALT_SEPARATOR
-   require 'tc_windows'
+   require 'test_sys_admin_windows'
 else
-   require 'tc_unix'
+   require 'test_sys_admin_unix'
+end
+
+class TC_Sys_Admin_All < Test::Unit::TestCase
+   def test_version
+      assert_equal('1.4.5', Sys::Admin::VERSION)
+   end
 end

data/test/test_sys_admin_unix.rb

@@ -0,0 +1,246 @@
+###############################################################################
+# test_sys_admin_unix.rb
+#
+# Test suite for the Unix version of sys-admin. This test should be run
+# via the 'rake test' task.
+###############################################################################
+require 'test/unit'
+require 'sys/admin'
+include Sys
+
+class TC_Sys_Admin_Unix < Test::Unit::TestCase
+   def setup
+      @user = 'nobody'
+      @user_id  = 0
+
+      @group = 'sys'
+      @group_id = 3
+   end
+
+   ## Admin singleton methods
+
+   def test_get_login
+      assert_respond_to(Admin, :get_login)
+      assert_nothing_raised{ Admin.get_login }
+      assert_kind_of(String, Admin.get_login)
+   end
+
+   def test_get_user_basic
+      assert_respond_to(Admin, :get_user)
+      assert_nothing_raised{ Admin.get_user(@user) }
+      assert_nothing_raised{ Admin.get_user(@user_id) }
+   end
+
+   def test_get_user_by_name
+      assert_kind_of(User, Admin.get_user(@user))
+   end
+
+   def test_get_user_by_id
+      assert_kind_of(User, Admin.get_user(@user_id))
+   end
+
+   def test_get_user_expected_errors
+      assert_raise(ArgumentError){ Admin.get_user }
+      assert_raise(TypeError){ Admin.get_user([]) }
+      assert_raise(Admin::Error){ Admin.get_user('foofoofoo') }
+   end
+
+   def test_users_basic
+      assert_respond_to(Admin, :users)
+      assert_nothing_raised{ Admin.users }
+   end
+
+   def test_users
+      assert_kind_of(Array, Admin.users)
+      assert_kind_of(User, Admin.users.first)
+   end
+
+   def test_users_block_form
+      array = []
+      assert_nothing_raised{ Admin.users{ |g| array << g } }
+      assert_equal(true, Admin.users.length == array.length)
+      assert_nothing_raised{ Admin.users{ |g| break } }
+   end
+
+   def test_users_expected_errors
+      assert_raise(ArgumentError){ Admin.users(@user_id) }
+   end
+
+   def test_get_group_basic
+      assert_respond_to(Admin, :get_group)
+      assert_nothing_raised{ Admin.get_group(@group) }
+      assert_nothing_raised{ Admin.get_group(@group_id) }
+   end
+
+   def test_get_group_by_name
+      assert_kind_of(Group, Admin.get_group(@group))
+   end
+
+   def test_get_group_by_id
+      assert_kind_of(Group, Admin.get_group(@group_id))
+   end
+
+   def test_get_group_expected_errors
+      assert_raise(ArgumentError){ Admin.get_group }
+      assert_raise(TypeError){ Admin.get_group([]) }
+      assert_raise(Admin::Error){ Admin.get_group('foofoofoo') }
+   end
+
+   def test_groups_basic
+      assert_respond_to(Admin, :groups)
+      assert_nothing_raised{ Admin.groups }
+   end
+
+   def test_groups
+      assert_kind_of(Array, Admin.groups)
+      assert_kind_of(Group, Admin.groups.first)
+   end
+
+   def test_groups_expected_errors
+      assert_raise(ArgumentError){ Admin.groups(@group_id) }
+   end
+
+   def test_groups_block_form
+      array = []
+      assert_nothing_raised{ Admin.groups{ |g| array << g } }
+      assert_equal(true, Admin.groups.length == array.length)
+      assert_nothing_raised{ Admin.groups{ |g| break } }
+   end
+
+   ## User Tests
+
+   def test_user_name
+      @user = Admin.users.first
+      assert_respond_to(@user, :name)
+      assert_kind_of(String, @user.name)
+   end
+
+   def test_user_passwd
+      @user = Admin.users.first
+      assert_respond_to(@user, :passwd)
+      assert_kind_of(String, @user.passwd)
+   end
+
+   def test_user_uid
+      @user = Admin.users.first
+      assert_respond_to(@user, :uid)
+      assert_kind_of(Fixnum, @user.uid)
+   end
+
+   def test_user_gid
+      @user = Admin.users.first
+      assert_respond_to(@user, :gid)
+      assert_kind_of(Fixnum, @user.gid)
+   end
+
+   def test_user_dir
+      @user = Admin.users.first
+      assert_respond_to(@user, :dir)
+      assert_kind_of(String, @user.dir)
+   end
+
+   def test_user_shell
+      @user = Admin.users.first
+      assert_respond_to(@user, :shell)
+      assert_kind_of(String, @user.shell)
+   end
+
+   def test_user_gecos
+      @user = Admin.users.first
+      assert_respond_to(@user, :gecos)
+      assert_kind_of(String, @user.gecos)
+   end
+
+   def test_user_quota
+      @user = Admin.users.first
+      assert_respond_to(@user, :quota)
+      assert_true([Fixnum, NilClass].include?(@user.quota.class))
+   end
+
+   def test_user_age
+      @user = Admin.users.first
+      assert_respond_to(@user, :age)
+      assert_true([Fixnum, NilClass].include?(@user.age.class))
+   end
+
+   def test_user_access_class
+      @user = Admin.users.first
+      assert_respond_to(@user, :access_class)
+      assert_true([String, NilClass].include?(@user.access_class.class))
+   end
+
+   def test_user_comment
+      @user = Admin.users.first
+      assert_respond_to(@user, :comment)
+      assert_true([String, NilClass].include?(@user.comment.class))
+   end
+
+   def test_user_expire
+      @user = Admin.users.first
+      assert_respond_to(@user, :expire)
+      assert_true([Time, NilClass].include?(@user.expire.class))
+   end
+
+   def test_user_change
+      @user = Admin.users.first
+      assert_respond_to(@user, :change)
+      assert_true([Time, NilClass].include?(@user.change.class))
+   end
+
+   def test_user_login_time
+      @user = Admin.users.first
+      assert_respond_to(@user, :login_time)
+      assert_true([Time, NilClass].include?(@user.login_time.class))
+   end
+
+   def test_user_login_device
+      @user = Admin.users.first
+      assert_respond_to(@user, :login_device)
+      assert_true([String, NilClass].include?(@user.login_device.class))
+   end
+
+   def test_user_login_host
+      @user = Admin.users.first
+      assert_respond_to(@user, :login_host)
+      assert_true([String, NilClass].include?(@user.login_host.class))
+   end
+
+   def test_user_groups
+      @user = Admin.users.first
+      assert_respond_to(@user, :groups)
+      assert_kind_of(Array, @user.groups)
+   end
+
+   ## Group Tests
+
+   def test_group_name
+      @group = Admin.groups.first
+      assert_respond_to(@group, :name)
+      assert_kind_of(String, @group.name)
+   end
+
+   def test_group_gid
+      @group = Admin.groups.first
+      assert_respond_to(@group, :gid)
+      assert_kind_of(Fixnum, @group.gid)
+   end
+
+   def test_group_members
+      @group = Admin.groups.first
+      assert_respond_to(@group, :members)
+      assert_kind_of(Array, @group.members)
+   end
+
+   def test_group_passwd
+      @group = Admin.groups.first
+      assert_respond_to(@group, :passwd)
+      assert_kind_of(String, @group.passwd)
+   end
+
+   def teardown
+      @user     = nil
+      @user_id  = nil
+      @group    = nil
+      @group_id = nil
+   end
+end

data/test/{tc_windows.rb → test_sys_admin_windows.rb}

@@ -1,5 +1,5 @@
 ###############################################################################
-# tc_windows.rb
+# test_sys_admin_windows.rb
 #
 # Test suite for the Win32 version of sys-admin.  Note that some of the tests
 # are numbered to ensure a certain order.  That way I can add test users
@@ -29,10 +29,6 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
       @group_id   = 546        # best guess, may fail
    end
 
-   def test_version
-      assert_equal('1.4.4', Admin::VERSION)
-   end
-   
    def test_01_add_local_user
       assert_respond_to(Admin, :add_local_user)
       assert_nothing_raised{ Admin.add_local_user('foo') }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sys-admin
 version: !ruby/object:Gem::Version 
-  version: 1.4.4
+  version: 1.4.5
 platform: ruby
 authors: 
 - Daniel J. Berger
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-19 00:00:00 -07:00
+date: 2009-01-26 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
-description: A unified, cross platform replacement for the "etc" package.
+description: A unified, cross platform replacement for the "etc" library.
 email: djberg96@gmail.com
 executables: []
 
@@ -27,15 +27,15 @@ extra_rdoc_files:
 files: 
 - doc/sys-admin-unix.txt
 - doc/sys-admin-windows.txt
-- examples/groups.rb
 - examples/users.rb
-- test/tc_admin.rb
-- test/tc_unix.rb
-- test/tc_windows.rb
-- CHANGES
+- examples/groups.rb
+- test/test_sys_admin_windows.rb
+- test/test_sys_admin.rb
+- test/test_sys_admin_unix.rb
 - MANIFEST
-- Rakefile
 - README
+- CHANGES
+- Rakefile
 - ext/sys/admin.c
 - ext/sys/admin.h
 has_rdoc: true
@@ -60,9 +60,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: sysutils
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
-summary: A unified, cross platform replacement for the "etc" package.
+summary: A unified, cross platform replacement for the "etc" library.
 test_files: 
-- test/tc_admin.rb
+- test/test_sys_admin.rb

data/test/tc_unix.rb

@@ -1,81 +0,0 @@
-###############################################################################
-# tc_unix.rb
-#
-# Test suite for the Unix version of sys-admin. This test should be run
-# via the 'rake test' task.
-###############################################################################
-require 'test/unit'
-require 'sys/admin'
-include Sys
-
-class TC_Sys_Admin_Unix < Test::Unit::TestCase
-   def setup
-      @user    = "nobody"
-      @userid  = 0
-      @group   = "sys"
-      @groupid = 3
-   end
-
-   def test_version
-      assert_equal('1.4.4', Admin::VERSION)
-   end
-
-   def test_get_login
-      assert_respond_to(Admin, :get_login)
-      assert_nothing_raised{ Admin.get_login }
-      assert_kind_of(String, Admin.get_login)
-   end
-
-   def test_get_user
-      assert_respond_to(Admin, :get_user)
-      assert_nothing_raised{ Admin.get_user(@user) }
-      assert_nothing_raised{ Admin.get_user(@userid) }
-      assert_kind_of(User, Admin.get_user(@user))
-      assert_kind_of(User, Admin.get_user(@userid))
-      assert_raises(Admin::Error){ Admin.get_user("foofoo") }
-   end
-
-   def test_users
-      assert_respond_to(Admin, :users)
-      assert_nothing_raised{ Admin.users }
-      assert_kind_of(Array, Admin.users)
-      assert_kind_of(User, Admin.users.first)
-   end
-
-   def test_users_block_form
-      array = []
-      assert_nothing_raised{ Admin.users{ |g| array << g } }
-      assert_equal(true, Admin.users.length == array.length)
-      assert_nothing_raised{ Admin.users{ |g| break } }
-   end
-
-   def test_get_group
-      assert_respond_to(Admin, :get_group)
-      assert_nothing_raised{ Admin.get_group(@group) }
-      assert_nothing_raised{ Admin.get_group(@groupid) }
-      assert_kind_of(Group, Admin.get_group(@group))
-      assert_kind_of(Group, Admin.get_group(@groupid))
-      assert_raises(Admin::Error){ Admin.get_group("foofoo") }
-   end
-
-   def test_groups
-      assert_respond_to(Admin, :groups)
-      assert_nothing_raised{ Admin.groups }
-      assert_kind_of(Array, Admin.groups)
-      assert_kind_of(Group, Admin.groups.first)
-   end
-
-   def test_groups_block_form
-      array = []
-      assert_nothing_raised{ Admin.groups{ |g| array << g } }
-      assert_equal(true, Admin.groups.length == array.length)
-      assert_nothing_raised{ Admin.groups{ |g| break } }
-   end
-
-   def teardown
-      @user    = nil
-      @userid  = nil
-      @group   = nil
-      @groupid = nil
-   end
-end