ad-framework 0.1.0

data/lib/ad-framework/attribute.rb

@@ -0,0 +1,35 @@
+require 'ad-framework/exceptions'
+
+module AD
+  module Framework
+
+    class Attribute
+      attr_accessor :name, :ldap_name, :attribute_type
+
+      def initialize(name)
+        self.name = name
+        definition = AD::Framework.defined_attributes.find(self.name)
+        if !definition
+          raise(AD::Framework::AttributeNotDefined, "There is no attribute defintion for #{name.inspect}.")
+        end
+        self.ldap_name = definition.ldap_name
+        self.attribute_type = AD::Framework.defined_attribute_types.find(definition.type)
+        if !self.attribute_type
+          raise(*[
+            AD::Framework::AttributeTypeNotDefined, 
+            "There is no attribute type defined for #{definition.type.inspect}"
+          ])
+        end
+      end
+
+      def define_reader(klass)
+        self.attribute_type.define_reader(self, klass)
+      end
+      def define_writer(klass)
+        self.attribute_type.define_writer(self, klass)
+      end
+
+    end
+  
+  end
+end

data/lib/ad-framework/attribute_type.rb

@@ -0,0 +1,133 @@
+module AD
+  module Framework
+
+    class AttributeType
+      attr_accessor :object, :attr_ldap_name, :value, :ldap_value
+
+      def initialize(object, attr_ldap_name, value = nil)
+        self.object = object
+        self.attr_ldap_name = attr_ldap_name
+        self.value = value.nil? ? self.value_from_field : value
+      end
+
+      def value_from_field
+        (self.object.fields[self.attr_ldap_name] || []).first
+      end
+
+      def value=(new_value)
+        @value = new_value
+        self.ldap_value = @value
+        @value
+      end
+
+      def ldap_value=(new_ldap_value)
+        self.object.fields[self.attr_ldap_name] = if new_ldap_value
+          [*new_ldap_value].collect(&:to_s)
+        else
+          []
+        end
+        @ldap_value = new_ldap_value
+      end
+      
+      def reset
+        self.value = self.value_from_field
+      end
+      
+      def is_set?
+        !self.value.nil?
+      end
+
+      def inspect
+        attr_display = [ :value, :ldap_value, :attr_ldap_name ].collect do |attr|
+          "#{attr}: #{self.instance_variable_get("@#{attr}").inspect}"
+        end
+        attr_display.push("object: #{object.class} - #{object.dn.inspect}")
+        [ "#<#{self.class} ", attr_display.sort.join(", "), ">" ].join
+      end
+
+      class << self
+
+        def key(new_value = nil)
+          if new_value
+            @key = new_value
+          end
+          @key
+        end
+
+        def define_attribute_type(attribute, klass)
+          method_name = "#{attribute.name}_attribute_type"
+          if !klass.instance_methods.collect(&:to_s).include?(method_name)
+            attribute_type_method = self.attribute_type_method(attribute, method_name)
+            if attribute_type_method.kind_of?(::Proc)
+              klass.class_eval(&attribute_type_method)
+            else
+              klass.class_eval(attribute_type_method.to_s)
+            end
+          end
+        end
+
+        def attribute_type_method(attribute, method_name)
+          <<-DEFINE_ATTRIBUTE_TYPE
+
+            def #{method_name}
+              unless @#{method_name}
+                type = #{attribute.attribute_type}.new(self, "#{attribute.ldap_name}")
+                @#{method_name} = type
+              end
+              @#{method_name}
+            end
+
+          DEFINE_ATTRIBUTE_TYPE
+        end
+
+        def define_reader(attribute, klass)
+          self.define_attribute_type(attribute, klass)
+          reader_method = self.reader_method(attribute)
+          if reader_method.kind_of?(::Proc)
+            klass.class_eval(&reader_method)
+          else
+            klass.class_eval(reader_method.to_s)
+          end
+        end
+
+        def reader_method(attribute)
+          <<-DEFINE_READER
+
+            def #{attribute.name}
+              self.#{attribute.name}_attribute_type.value
+            end
+
+          DEFINE_READER
+        end
+
+        def define_writer(attribute, klass)
+          self.define_attribute_type(attribute, klass)
+          writer_method = self.writer_method(attribute)
+          if writer_method.kind_of?(::Proc)
+            klass.class_eval(&writer_method)
+          else
+            klass.class_eval(writer_method.to_s)
+          end
+        end
+
+        def writer_method(attribute)
+          <<-DEFINE_WRITER
+
+            def #{attribute.name}=(new_value)
+              self.#{attribute.name}_attribute_type.value = new_value
+              if self.respond_to?("#{attribute.name}")
+                self.#{attribute.name}
+              else
+                new_value
+              end
+            end
+
+          DEFINE_WRITER
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/ad-framework/auxiliary_class.rb

@@ -0,0 +1,24 @@
+require 'ad-framework/patterns/has_schema'
+
+module AD
+  module Framework
+
+    module AuxiliaryClass      
+      class << self
+        
+        def included(klass)
+          klass.class_eval do
+            include AD::Framework::Patterns::HasSchema
+            
+            def self.included(klass)
+              super
+              klass.schema.add_auxiliary_class(self)
+            end
+          end
+        end
+        
+      end
+    end
+
+  end
+end

data/lib/ad-framework/config.rb

@@ -0,0 +1,72 @@
+require 'ad-ldap'
+
+require 'ad-framework/config/mapping'
+require 'ad-framework/config/attribute_definition'
+
+module AD
+  module Framework
+
+    class Config
+      attr_accessor :attributes, :attribute_types, :object_classes, :ldap_prefix
+
+      def initialize
+        self.mappings = AD::Framework::Config::Mapping.new
+        self.mappings.add(:dn, "distinguishedname")
+
+        self.attributes = AD::Framework::Config::Mapping.new
+        self.attribute_types = AD::Framework::Config::Mapping.new
+        self.object_classes = AD::Framework::Config::Mapping.new
+      end
+
+      def ldap_prefix=(new_value)
+        @ldap_prefix = new_value
+        self.object_classes.dup.each do |key, value|
+          self.object_classes.delete(key)
+          self.object_classes.add("#{@ldap_prefix}#{key}", value)
+        end
+      end
+
+      def ldap(&block)
+        if block
+          AD::LDAP.configure(&block)
+        end
+        AD::LDAP
+      end
+      alias :adapter :ldap
+
+      def logger
+        self.adapter.logger
+      end
+      def logger=(new_logger)
+        self.adapter.config.logger = new_logger
+      end
+
+      [ :search_size_supported, :mappings, :run_commands, :treebase ].each do |method|
+
+        define_method(method) do
+          self.adapter.config.send(method)
+        end
+
+        writer = "#{method}="
+        define_method(writer) do |new_value|
+          self.adapter.config.send(writer, new_value)
+        end
+
+      end
+
+      def add_attribute(attribute)
+        definition = AD::Framework::Config::AttributeDefinition.new(attribute)
+        self.mappings.add(definition.name, definition.ldap_name)
+        self.attributes.add(definition.name, definition)
+      end
+      def add_attribute_type(attribute_type)
+        self.attribute_types.add(attribute_type.key, attribute_type)
+      end
+      def add_object_class(object_class)
+        self.object_classes.add(object_class.ldap_name, object_class)
+      end
+
+    end
+
+  end
+end

data/lib/ad-framework/config/attribute_definition.rb

@@ -0,0 +1,18 @@
+module AD
+  module Framework
+    class Config
+
+      class AttributeDefinition
+        attr_accessor :name, :ldap_name, :type
+
+        def initialize(attributes)
+          attributes.each do |key, value|
+            self.send("#{key}=", value)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/ad-framework/config/mapping.rb

@@ -0,0 +1,26 @@
+module AD
+  module Framework
+    class Config
+
+      class Mapping < Hash
+      
+        def [](lookup)
+          super(lookup.to_sym)
+        end
+        def find(lookup)
+          self[lookup]
+        end
+      
+        def []=(lookup, object)
+          super(lookup.to_sym, object)
+        end
+
+        def add(lookup, object)
+          self[lookup] = object
+        end
+
+      end
+
+    end
+  end
+end

data/lib/ad-framework/exceptions.rb

@@ -0,0 +1,17 @@
+module AD
+  module Framework
+
+    class AttributeNotDefined < StandardError
+    end
+
+    class AttributeTypeNotDefined < StandardError
+    end
+
+    class ObjectClassNotDefined < StandardError
+    end
+
+    class EntryNotFound < StandardError
+    end
+
+  end
+end

data/lib/ad-framework/fields.rb

@@ -0,0 +1,44 @@
+module AD
+  module Framework
+
+    class Fields < Hash
+
+      def initialize(ldap_entry)
+        super()
+        @changed_keys = Set.new
+        (ldap_entry || {}).each do |ldap_name, value|
+          self[ldap_name.to_s] = value
+        end
+      end
+
+      def [](lookup)
+        super(lookup.to_s)
+      end
+      def []=(lookup, value)
+        if self[lookup] != value
+          @changed_keys << lookup.to_s
+        end
+        super(lookup.to_s, value)
+      end
+
+      def changes
+        @changed_keys.inject({}){|h, k| h.merge({ k => self[k] }) }
+      end
+
+      def to_hash
+        self.inject({}){|h, (k,v)| h.merge({ k => v }) }
+      end
+
+      def inspect
+        max_key_length = (self.keys.collect(&:size).max || 0) + 1
+        display = self.collect do |(key, value)|
+          key_label = "#{key}:".rjust(max_key_length, ' ')
+          [ key_label, value.inspect ].join("  ")
+        end
+        "\n#{display.join("\n")}"
+      end
+
+    end
+
+  end
+end

data/lib/ad-framework/patterns/callbacks.rb

@@ -0,0 +1,47 @@
+require 'ad-framework/utilities/transaction'
+
+module AD
+  module Framework
+    module Patterns
+
+      module Callbacks
+        class << self
+
+          def included(klass)
+            klass.class_eval do
+              include AD::Framework::Patterns::Callbacks::InstanceMethods
+            end
+          end
+
+        end
+        
+        module InstanceMethods
+          
+          def create
+            transaction = AD::Framework::Utilities::Transaction.new(:create, self) do
+              super
+            end
+            transaction.run
+          end
+          
+          def update
+            transaction = AD::Framework::Utilities::Transaction.new(:update, self) do
+              super
+            end
+            transaction.run
+          end
+          
+          def destroy
+            transaction = AD::Framework::Utilities::Transaction.new(:destroy, self) do
+              super
+            end
+            transaction.run
+          end
+          
+        end
+        
+      end
+
+    end
+  end
+end

data/lib/ad-framework/patterns/has_schema.rb

@@ -0,0 +1,127 @@
+require 'ad-framework/schema'
+
+module AD
+  module Framework
+    module Patterns
+
+      module HasSchema
+        class << self
+
+          def included(klass)
+            klass.class_eval do
+              extend AD::Framework::Patterns::HasSchema::ClassMethods
+              include AD::Framework::Patterns::HasSchema::InstanceMethods
+            end
+          end
+
+        end
+
+        module InstanceMethods
+
+          def schema
+            @schema ||= self.class.schema.dup
+          end
+
+          def dn
+            dn = self.fields[:distinguishedname] || self.fields[:dn]
+            dn ||= if self.respond_to?(self.schema.rdn)
+              [ "CN=#{self.send(self.schema.rdn)}", self.schema.treebase ].join(", ")
+            end
+          end
+
+          def attributes
+            self.schema.attributes.inject({}) do |attrs, name|
+              attrs.merge({ name.to_sym => self.send(name.to_sym) })
+            end
+          end
+          def attributes=(new_attributes)
+            new_attributes.each do |name, value|
+              if self.schema.attributes.include?(name)
+                self.send("#{name}=", value)
+              end
+            end
+          end
+
+        end
+
+        module ClassMethods
+
+          def schema
+            @schema ||= AD::Framework::Schema.new(self)
+          end
+
+          def ldap_name(name = nil)
+            (self.schema.ldap_name = name) if name
+            self.schema.ldap_name
+          end
+
+          def treebase(value = nil)
+            (self.schema.treebase = value) if value
+            self.schema.treebase
+          end
+
+          def rdn(name = nil)
+            (self.schema.rdn = name) if name
+            self.schema.rdn
+          end
+
+          # Attributes methods
+          def attributes(*attribute_names)
+            self.schema.add_attributes(attribute_names)
+          end
+
+          def read_attributes(*attribute_names)
+            self.schema.add_read_attributes(attribute_names)
+          end
+
+          def write_attributes(*attribute_names)
+            self.schema.add_write_attributes(attribute_names)
+          end
+
+          # Validation methods
+          def must_set(*attribute_names)
+            self.schema.add_mandatory(attribute_names)
+          end
+
+          # Callbacks methods
+          def before_create(*method_names)
+            self.schema.add_callback(:before, :create, method_names)
+          end
+
+          def before_update(*method_names)
+            self.schema.add_callback(:before, :update, method_names)
+          end
+
+          def before_save(*method_names)
+            self.before_create(*method_names)
+            self.before_update(*method_names)
+          end
+
+          def before_destroy(*method_names)
+            self.schema.add_callback(:before, :destroy, method_names)
+          end
+
+          def after_create(*method_names)
+            self.schema.add_callback(:after, :create, method_names)
+          end
+
+          def after_update(*method_names)
+            self.schema.add_callback(:after, :update, method_names)
+          end
+
+          def after_save(*method_names)
+            self.after_create(*method_names)
+            self.after_update(*method_names)
+          end
+
+          def after_destroy(*method_names)
+            self.schema.add_callback(:after, :destroy, method_names)
+          end
+
+        end
+
+      end
+
+    end
+  end
+end