goz 0.0.3 → 0.1.0

data/lib/goz/service/base.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'goz/service'
+require 'goz/logger'
+
+
+module  Goz     # :nodoc:
+  class Service # :nodoc:
+ 
+    # 
+    # = Goz::Service::Base - TODO
+    #   
+    # == Usage
+    #
+    # TODO
+    #  
+    # == Author
+    #
+    # blair christensen. <mailto:blair.christensen@gmail.com>
+    #
+    # == Homepage
+    #
+    # https://github.com/blairc/goz/
+    #
+    class Base
+
+      TAG = self.name
+
+      @@cf = {}
+
+
+      #
+      # Set configuration.
+      #
+      def self.configuration(configuration)
+        @@cf = configuration
+      end
+
+    end
+
+  end
+end
+

data/lib/goz/service/fake_service.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+require 'goz/service/base'
+require 'yaml'
+
+
+module  Goz     # :nodoc:
+  class Service # :nodoc:
+ 
+    # 
+    # = Goz::Service:FakeService - TODO
+    #   
+    # == Usage
+    #
+    # TODO
+    #  
+    # == Author
+    #
+    # blair christensen. <mailto:blair.christensen@gmail.com>
+    #
+    # == Homepage
+    #
+    # https://github.com/blairc/goz/
+    #
+    class FakeService < Goz::Service::Base
+
+      FN  = 'fake_service_database.yaml'
+      TAG = self.name
+
+      @@registry = nil
+
+
+      # XXX ALL UGLY HACKS!
+      def self.create(g)
+        Goz::Logger.debug TAG, "create( group.name=#{g.name} )"
+        load_registry
+        if @@registry.key? g.name
+          Goz::Logger.info TAG, "create( group.name=#{g.name} ) - group exists"
+          return true
+        end
+        Goz::Logger.info TAG, "create( group.name=#{g.name} ) - creating group"
+        @@registry[ g.name ] = { :group => g.to_hash }
+        save_registry
+      end
+
+      def self.load_registry
+        return @@registry unless @@registry.nil?
+        @@registry = File.exist?(FN) ? YAML.load_file(FN) : {}
+      end
+
+      def self.save_registry
+        File.open(FN, 'w') { |fh| fh.write YAML.dump(@@registry) }
+      end
+
+      def self.destroy(g)
+        Goz::Logger.debug TAG, "destroy( group.name=#{g.name} )"
+        load_registry
+        unless @@registry.key? g.name
+          Goz::Logger.info TAG, "destroy( group.name=#{g.name} ) - does not exist"
+          return true
+        end
+        Goz::Logger.info TAG, "destroy( group.name=#{g.name} ) - deleting group"
+        @@registry.delete g.name
+        save_registry
+      end
+
+      def self.sync_group(g, s)
+        Goz::Logger.debug TAG, "sync_group( group.name=#{g.name}, service.name=#{s.name} )"
+        load_registry
+        create(g) unless @@registry.key? g.name
+        @@registry[ g.name ][ :admins ]  = {}
+        @@registry[ g.name ][ :members ] = {}
+        g.admins.each  { |u| @@registry[ g.name ][:admins][ u.login ]  = u.to_hash }
+        g.members.each { |u| @@registry[ g.name ][:members][ u.login ] = u.to_hash }
+        save_registry
+      end
+
+    end
+  end
+end
+

data/lib/goz/test_case.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 
+require 'digest/sha1'
 require 'goz/database'
 require 'test/unit'
 
@@ -26,23 +27,34 @@ module Goz # :nodoc:
         [ :groups, :services, :users ].each { |t| db[t].delete }
       end
 
-      @groups = {
-        :a => { :display_name => 'Group:A', :identifier => 'c6347f2a0375db1e2ebfe0ad70e24172a3193037', :name => 'gA' },
-        :b => { :display_name => 'Group:B', :identifier => '341af322e54bea31f8d08d4f2c627a4db341781a', :name => 'gB' }
-      }
+      @groups = {}
+      [ :a, :b ].each do |sym|
+        @groups[sym] = { :display_name => "Group:#{ sym.to_s.upcase }",
+                         :identifier   => Digest::SHA1.hexdigest( sym.to_s ),
+                         :klass        => 'Goz::Group',
+                         :name         => "g#{ sym.to_s.upcase }"
+                       }
+      end
 
-      @services = {
-        :a => { :name => 'Service A', :klass => 'Goz::Service' },
-        :b => { :name => 'Service B', :klass => 'Goz::Service' }
-      }
+      @services = {}
+      [ :a, :b ].each do |sym|
+        @services[sym] = { :name  => "Service #{ sym.to_s.upcase }",
+                           :klass => 'Goz::Service'
+                         }
+      end
 
-      @users = {
-        :a => { :email => 'a@example.org', :login => 'uA', :identifier => '40b071bd23a8fd2b8cff7f59da9211dca7806d47', :name => 'User A' },
-        :b => { :email => 'b@example.org', :login => 'uB', :identifier => '40b071bd23a8fd2b8cff7f59da9211dca7806d47', :name => 'User B' }
-      }
+      @users = {}
+      [ :a, :b ].each do |sym|
+        @users[sym] = { :email      => "#{ sym.to_s }@example.org",
+                        :identifier => Digest::SHA1.hexdigest( sym.to_s ),
+                        :klass      => 'Goz::User',
+                        :login      => sym.to_s,
+                        :name       => "User #{ sym.to_s.upcase }"
+                       }
+      end
     end
 
-  end # class TestCase
+  end
 
-end # module Goz
+end
 

data/lib/goz/user.rb

@@ -1,7 +1,10 @@
 # encoding: utf-8
 
+require 'active_support/inflector'
 require 'goz/database'
 require 'goz/event'
+require 'goz/logger'
+
 
 module Goz # :nodoc:
  
@@ -35,7 +38,6 @@ module Goz # :nodoc:
   # https://github.com/blairc/goz/
   #
   class User < Sequel::Model
-    include Comparable
 
     plugin :validation_helpers
 
@@ -55,76 +57,89 @@ module Goz # :nodoc:
                   :after_remove => proc { |u, g| Goz::Event.member_remove(g, u) }
 
 
+    ATTRIBUTES = [ :email, :identifier, :klass, :login, :name ]
+    TAG = self.name
+
+    @@api = Goz::User # XXX
+
+
     #
     # Initialize new (non-persistent) Goz::User object
     #
-    def initialize(*params)
+    def initialize( *params )
       super
       yield self if block_given?
       self
     end
 
     #
-    # Compare equality.
+    # TODO
     #
-    def <=>(other)
-      if    self.login      < other.login       ||
-            self.email      < other.email       ||
-            self.name       < other.name        ||
-            self.identifier < other.identifier
-        -1
-      elsif self.login      > other.login       ||
-            self.email      > other.email       ||
-            self.name       > other.name        ||
-            self.identifier > other.identifier
-        1
-      else
-        0
-      end
+    def self.api( klass = nil, configuration = {} )
+      return @@api if klass.nil?
+      Goz::Logger.info TAG, "changing api from #{@@api} to #{klass}"
+      klass_name = klass.kind_of?(String) ? klass : klass.name
+      require klass_name.underscore
+      klass = klass.constantize if klass.kind_of?(String)
+      klass.configuration configuration
+      @@api = klass
     end
 
     #
-    # Create Goz::User or raise +RuntimeError+
+    # Find Goz::User by identifier or return +nil+
     #
-    def self.create( params = {} )
-      params = {} unless params.kind_of?(Hash)
-      [ :email, :identifier, :login, :name ].each do |k|
-        raise( "invalid #{k.to_s}" ) if ( params[k].nil? || params[k].empty? )
+    def self.find_by_identifier(identifier)
+      Goz::Logger.debug TAG, "find_by_identifier( identifier=#{identifier} )"
+      u = self.find :identifier => identifier
+      return u   unless u.nil?
+      return nil if     Goz::User == self.api
+      u = self.api.find_by_identifier identifier
+      return nil if u.nil?
+      begin
+        return self.find_or_create u.to_hash
+      rescue => e
+        Goz::Logger.error TAG, "find_by_identifier( identifier=#{identifier} ) => #{ e.to_s }"
       end
-      super
+      return nil
     end
 
     #
     # Find Goz::User by login or return +nil+
     #
     def self.find_by_login(login)
-      Goz::Database.instance do |db|
-        return User.find( :login => login )
-      end
+      Goz::Logger.debug TAG, "find_by_login( login=#{login} )"
+      u = self.find :login => login
+      return u   unless u.nil?
+      return nil if     Goz::User == self.api
+      u = self.api.find_by_login login
+      return nil if u.nil?
+      return self.find_or_create u.to_hash
     end
 
     #
     # Synchronize user with external data sources (if relevant).
     # 
     def sync(force = false)
-      if force || synchronized_at.nil? || synchronized_at < ( Time.now - ( 1 * 60 * 60 ) ) # XXX
-        # XXX Synchronize user with remote source (if necessary)
-        # XXX Synchronize groups
-        # XXX Synchronize memberships
-        self.synchronized_at = Time.now
-        self.save
-        Goz::Event.user_sync(self)
-        return true
+      Goz::Logger.debug TAG, "#{self.login} - #sync( force=#{force} )"
+        if sync_user && sync_groups && sync_memberships
+          self.synchronized_at = Time.now
+          self.save
+          Goz::Event.user_sync(self)
+          return true
       end
       false
     end
 
+    def to_hash
+      Hash[ ATTRIBUTES.map { |k| [ k, self[k] ] } ]
+    end
+
     #
     # Perform model valiations.
     #
     def validate
       super
-      validates_presence  [ :email, :identifier, :login, :name ]
+      validates_presence  [ :email, :identifier, :klass, :login, :name ]
       validates_type      Time, [ :created_at, :modified_at, :synchronized_at ]
       validates_unique    [ :email, :identifier, :login ]
     end
@@ -134,12 +149,12 @@ module Goz # :nodoc:
 
     def after_destroy
       super
-      Event.create :event_type_id => Goz::EventType::USER_REMOVE, :user_id => self.id
+      Goz::Event.user_remove(self)
     end
 
     def after_create
       super
-      Event.create :event_type_id => Goz::EventType::USER_ADD, :user_id => self.id
+      Goz::Event.user_add(self)
     end
 
     def before_create
@@ -158,6 +173,52 @@ module Goz # :nodoc:
       self.modified_at = Time.now
     end
 
+    def klass_instance
+      return @@api if @@api.name == self.klass
+      unless @k
+        @k = self.klass.constantize
+        require self.klass.underscore
+      end
+      return @k
+    end
+
+    # Synchronize user groups with external data source
+    def sync_groups
+      Goz::Logger.debug TAG, "#{self.login} - #sync_groups()"
+      # TODO Does Sequel provide a better option for this?
+      t = Goz::Group.admin(self)
+      t.each           { |_| self.add_group(_)    unless self.groups.include?(_) }
+      self.groups.each { |_| self.remove_group(_) unless t.include?(_)           }
+      # TODO Log! if modified?
+      true
+    end
+
+    # Synchronize user memberships with external data source
+    def sync_memberships
+      Goz::Logger.debug TAG, "#{self.login} - #sync_memberships()"
+      # TODO Does Sequel provide a better option for this?
+      t = Goz::Group.member(self)
+      t.each                { |_| self.add_membership(_)    unless self.memberships.include?(_) }
+      self.memberships.each { |_| self.remove_membership(_) unless t.include?(_)                }
+      # TODO Log! if modified?
+      true
+    end
+
+    # Synchronize user with external data source
+    def sync_user
+      Goz::Logger.debug TAG, "#{self.login} - #sync_user()"
+      return true if Goz::User.name == self.klass
+      u = klass_instance.find_by_login self.login
+      return false if u.nil?
+      [ :email, :identifier, :login, :name ].each do |attr|
+        unless self[attr] == u[attr]
+          Goz::Logger.info TAG, "#{self.login} = #sync_user() - #{attr} changed"
+          self[attr] = u[attr]
+        end
+      end
+      true
+    end
+
   end # class User
 
 end # module Goz

data/lib/goz/user/base.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+require 'goz/logger'
+require 'goz/user'
+
+
+module  Goz   # :nodoc:
+  class User  # :nodoc:
+ 
+    # 
+    # = Goz::User::Base - TODO
+    #   
+    # == Usage
+    #
+    # TODO
+    #  
+    # == Author
+    #
+    # blair christensen. <mailto:blair.christensen@gmail.com>
+    #
+    # == Homepage
+    #
+    # https://github.com/blairc/goz/
+    #
+    class Base
+
+      TAG = self.name
+
+      attr_accessor :email, :identifier, :klass, :login, :name
+
+      @@cf = {}
+
+
+      #
+      # TODO 
+      #
+      def [](key)
+        send key.to_sym
+      end
+
+      #
+      # Set configuration.
+      #
+      def self.configuration(configuration)
+        @@cf = configuration
+      end
+
+      #
+      # Find Goz::User by login or return +nil+.
+      #
+      # MUST be implemented by API extensions.
+      #
+      def self.find_by_login(login)
+        raise RuntimeError, "not implemented"
+      end
+
+      #
+      # Convert to Goz::User-style hash
+      #
+      def to_hash
+        return { :email      => self.email,
+                 :identifier => self.identifier,
+                 :klass      => self.klass,
+                 :login      => self.login,
+                 :name       => self.name
+               }
+      end
+
+      #
+      # TODO
+      # 
+      def to_s
+        "email=#{email} | identifier=#{identifier} | klass=#{klass} | login=#{login} | name=#{name}"
+      end
+
+
+    end
+
+  end
+end
+