activeldap 1.2.0 → 1.2.1

data/lib/active_ldap/association/proxy.rb

@@ -70,7 +70,11 @@ module ActiveLdap
       end
 
       def primary_key
-        @options[:primary_key_name] || foreign_class.dn_attribute
+        @options[:primary_key_name] || @owner.dn_attribute
+      end
+
+      def foreign_key
+        @options[:foreign_key_name] || foreign_class.dn_attribute
       end
 
       def load_target

data/lib/active_ldap/associations.rb

@@ -125,13 +125,13 @@ module ActiveLdap
           :extend => options[:extend],
         }
         if opts[:wrap]
-          opts[:foreign_key_name] ||= "#{association_id}_id"
           association_class = Association::HasManyWrap
         else
           association_class = Association::HasMany
           primary_key_name = opts[:primary_key_name]
           foreign_key_name = opts[:foreign_key_name]
           if primary_key_name != foreign_key_name and
+              primary_key_name != "dn" and
               !new.have_attribute?(primary_key_name)
             message = _(":primary_key and :foreign_key has_many options are " \
                         "inverted their mean since 1.1.0. Please invert them.")

data/lib/active_ldap/attributes.rb

@@ -101,8 +101,7 @@ module ActiveLdap
             if value.is_a?(Hash)
               suffix, real_value = unnormalize_attribute_options(value)
               new_name = name + suffix
-              result[new_name] ||= []
-              result[new_name].concat(real_value)
+              unnormalize_attribute(new_name, real_value, result)
             else
               result[name] ||= []
               if value.is_a?(DN)
@@ -157,7 +156,13 @@ module ActiveLdap
         needless_attributes[to_real_attribute_name(name)] = true
       end
 
+      _dn_attribute = nil
+      begin
+        _dn_attribute = dn_attribute_with_fallback
+      rescue DistinguishedNameInvalid
+      end
       targets.collect do |key, value|
+        key = _dn_attribute if ["id", "dn"].include?(key.to_s)
         [to_real_attribute_name(key) || key, value]
       end.reject do |key, value|
         needless_attributes[key]
@@ -165,7 +170,6 @@ module ActiveLdap
     end
 
     def attributes_protected_by_default
-      _dn_attribute = nil
       begin
         _dn_attribute = dn_attribute_with_fallback
       rescue DistinguishedNameInvalid

data/lib/active_ldap/base.rb

@@ -780,7 +780,6 @@ module ActiveLdap
 
     def dn=(value)
       set_attribute(dn_attribute_with_fallback, value)
-      @dn = nil
     end
     alias_method(:id=, :dn=)
 
@@ -902,7 +901,8 @@ module ActiveLdap
     # This returns the key value pairs in @data with all values
     # cloned
     def attributes
-      @data.clone
+      @simplified_data ||= simplify_data(@data)
+      @simplified_data.clone
     end
 
     # This allows a bulk update to the attributes of a record
@@ -1276,6 +1276,7 @@ module ActiveLdap
       raise UnknownAttribute.new(name) if real_name.nil?
 
       @data[real_name] = value
+      @simplified_data = nil
     end
 
     def register_new_dn_attribute(name, value)
@@ -1443,6 +1444,19 @@ module ActiveLdap
       result
     end
 
+    def simplify_data(data)
+      _schema = schema
+      result = {}
+      data.each do |key, values|
+        attribute = _schema.attribute(key)
+        if attribute.single_value? and values.is_a?(Array) and values.size == 1
+          values = values[0]
+        end
+        result[key] = type_cast(attribute, values)
+      end
+      result
+    end
+
     def collect_modified_attributes(ldap_data, data)
       klass = self.class
       _dn_attribute = dn_attribute

data/lib/active_ldap/distinguished_name.rb

@@ -246,21 +246,18 @@ module ActiveLdap
       normalize(@rdns).to_s.hash
     end
 
-    def inspect
-      super
-    end
-
     def to_s
+      klass = self.class
       @rdns.collect do |rdn|
         rdn.sort_by do |type, value|
           type.upcase
         end.collect do |type, value|
-          "#{type}=#{self.class.escape_value(value)}"
+          "#{type}=#{klass.escape_value(value)}"
         end.join("+")
       end.join(",")
     end
 
-    def to_str
+    def to_str # for backward compatibility
       to_s
     end
 

data/lib/active_ldap/operations.rb

@@ -129,18 +129,21 @@ module ActiveLdap
       def truncate_base(target)
         return nil if target.blank?
         return target if base.nil?
-        if /,/ =~ target
+
+        parsed_target = nil
+        if target.is_a?(DN)
+          parsed_target = target
+        elsif /,/ =~ target
           begin
             parsed_target = DN.parse(target)
-            begin
-              (parsed_target - base).to_s
-            rescue ArgumentError
-              target
-            end
           rescue DistinguishedNameInvalid
-            target
           end
-        else
+        end
+
+        return target if parsed_target.nil?
+        begin
+          (parsed_target - base).to_s
+        rescue ArgumentError
           target
         end
       end

data/lib/active_ldap/timeout_stub.rb

@@ -3,7 +3,7 @@ require 'timeout'
 module Timeout
   # STUB
   def Timeout.alarm(sec, exception=Timeout::Error, &block)
-    return block.call
+    timeout(sec, exception, &block)
   end
 end # Timeout
 

data/lib/active_ldap/xml.rb

@@ -57,14 +57,17 @@ module ActiveLdap
 
       def normalize_value(value, options=[])
         targets = []
-        if value.is_a?(Hash)
+        case value
+        when Hash
           value.each do |real_option, real_value|
             targets.concat(normalize_value(real_value, options + [real_option]))
           end
-        elsif value.is_a?(Array)
+        when Array
           value.each do |real_value|
             targets.concat(normalize_value(real_value, options))
           end
+        when DN
+          targets.concat(normalize_value(value.to_s, options))
         else
           if /\A#{PRINTABLE_STRING}\z/ !~ value
             value = [value].pack("m").gsub(/\n/u, '')

data/test-unit/History.txt

@@ -1,3 +1,57 @@
+=== 2.0.6 / 20XX-XX-XX
+
+* X major enhancements
+  * [#27380] Declarative syntax? [Daniel Berger]
+    support declarative syntax:
+
+      test "test description in natural language" do
+         ...
+      end
+  * support test description:
+      description "test description in natural language"
+      def test_my_test
+         ...
+      end
+
+* X bug fixes
+  * [#27374] omit_if unexpected behavior [David MARCHALAND]
+  * fix a bug that tests in sub directories aren't load with --basedir.
+    [Daniel Berger]
+
+* Thanks
+  * David MARCHALAND
+  * Daniel Berger
+
+=== 2.0.5 / 2009-10-18
+
+* 1 bug fixes
+  * [#27314] fix diff may raise an exception. [Erik Hollensbe]
+
+* Thanks
+  * Erik Hollensbe
+
+=== 2.0.4 / 2009-10-17
+
+* 4 major enhancements
+  * use ~/.test-unit.yml as global configuration file.
+  * add TAP runner. (--runner tap)
+  * support colorized diff:
+    http://test-unit.rubyforge.org/svn/trunk/images/color-diff.png
+  * add Test::Unit::AutoRunner.default_runner= to specify default test runner.
+
+* 4 minor enhancements
+  * improve verbose mode output format. (use indent)
+  * support NOT_PASS_THROUGH_EXCEPTIONS.
+  * support arguments option in #{runner}_options.
+  * TC_ -> Test in sample test case name.
+
+* 1 bug fixes
+  * [#27195] test-unit-2.0.3 + ruby-1.9.1 cannot properly test
+    DelegateClass subclasses [Mike Pomraning]
+
+* Thanks
+  * Mike Pomraning
+
 === 2.0.3 / 2009-07-19
 
 * 6 major enhancements

data/test-unit/Manifest.txt

@@ -8,6 +8,7 @@ html/classic.html
 html/index.html
 html/index.html.ja
 html/test-unit-classic.png
+images/color-diff.png
 lib/test/unit.rb
 lib/test/unit/assertionfailederror.rb
 lib/test/unit/assertions.rb
@@ -49,10 +50,9 @@ lib/test/unit/util/procwrapper.rb
 lib/test/unit/version.rb
 sample/adder.rb
 sample/subtracter.rb
-sample/tc_adder.rb
-sample/tc_subtracter.rb
+sample/test_adder.rb
+sample/test_subtracter.rb
 sample/test_user.rb
-sample/ts_examples.rb
 test/collector/test-descendant.rb
 test/collector/test-load.rb
 test/collector/test_dir.rb

data/test-unit/README.txt

@@ -46,7 +46,10 @@ This software is distributed under the same terms as ruby.
 
 * Daniel Berger: Suggestions and bug reports.
 * Designing Patterns: Suggestions.
-* Erik Hollensbe: Suggestions.
+* Erik Hollensbe: Suggestions and bug reports.
 * Bill Lear: A suggestion.
 * Diego Pettenò: A bug report.
 * Angelo Lakra: A bug report.
+* Mike Pomraning: A bug report.
+* David MARCHALAND: A bug report.
+* Andrew Grimm: A bug report.

data/test-unit/lib/test/unit.rb

@@ -179,7 +179,7 @@ module Test # :nodoc:
   #
   #     require 'test/unit'
   #     
-  #     class TC_MyTest < Test::Unit::TestCase
+  #     class MyTest < Test::Unit::TestCase
   #       # def setup
   #       # end
   #     
@@ -194,21 +194,17 @@ module Test # :nodoc:
   #
   # == Test Runners
   #
-  # So, now you have this great test class, but you still need a way to
-  # run it and view any failures that occur during the run. This is
-  # where Test::Unit::UI::Console::TestRunner (and others, such as
-  # Test::Unit::UI::GTK::TestRunner) comes into play. The console test
-  # runner is automatically invoked for you if you require 'test/unit'
-  # and simply run the file. To use another runner, or to manually
-  # invoke a runner, simply call its run class method and pass in an
-  # object that responds to the suite message with a
-  # Test::Unit::TestSuite. This can be as simple as passing in your
-  # TestCase class (which has a class suite method). It might look
-  # something like this:
-  #
-  #    require 'test/unit/ui/console/testrunner'
-  #    Test::Unit::UI::Console::TestRunner.run(TC_MyTest)
+  # So, now you have this great test class, but you still
+  # need a way to run it and view any failures that occur
+  # during the run. There are some test runner; console test
+  # runner, GTK+ test runner and so on. The console test
+  # runner is automatically invoked for you if you require
+  # 'test/unit' and simply run the file. To use another
+  # runner simply set default test runner ID to
+  # Test::Unit::AutoRunner:
   #
+  #    require 'test/unit'
+  #    Test::Unit::AutoRunner.default_runner = "gtk2"
   #
   # == Test Suite
   #
@@ -220,33 +216,17 @@ module Test # :nodoc:
   # in response to a suite method. The TestSuite can, in turn, contain
   # other TestSuites or individual tests (typically created by a
   # TestCase). In other words, you can easily wrap up a group of
-  # TestCases and TestSuites like this:
-  #
-  #  require 'test/unit/testsuite'
-  #  require 'tc_myfirsttests'
-  #  require 'tc_moretestsbyme'
-  #  require 'ts_anothersetoftests'
-  #
-  #  class TS_MyTests
-  #    def self.suite
-  #      suite = Test::Unit::TestSuite.new
-  #      suite << TC_MyFirstTests.suite
-  #      suite << TC_MoreTestsByMe.suite
-  #      suite << TS_AnotherSetOfTests.suite
-  #      return suite
-  #    end
-  #  end
-  #  Test::Unit::UI::Console::TestRunner.run(TS_MyTests)
-  #
-  # Now, this is a bit cumbersome, so Test::Unit does a little bit more
-  # for you, by wrapping these up automatically when you require
-  # 'test/unit'. What does this mean? It means you could write the above
-  # test case like this instead:
+  # TestCases and TestSuites.
+  #
+  # Test::Unit does a little bit more for you, by wrapping
+  # these up automatically when you require
+  # 'test/unit'. What does this mean? It means you could
+  # write the above test case like this instead:
   #
   #  require 'test/unit'
-  #  require 'tc_myfirsttests'
-  #  require 'tc_moretestsbyme'
-  #  require 'ts_anothersetoftests'
+  #  require 'test_myfirsttests'
+  #  require 'test_moretestsbyme'
+  #  require 'test_anothersetoftests'
   #
   # Test::Unit is smart enough to find all the test cases existing in
   # the ObjectSpace and wrap them up into a suite for you. It then runs
@@ -323,12 +303,13 @@ module Test # :nodoc:
   #
 
   module Unit
-    # If set to false Test::Unit will not automatically run at exit.
+    # Set true when Test::Unit has run.  If set to true Test::Unit
+    # will not automatically run at exit.
     def self.run=(flag)
       @run = flag
     end
 
-    # Automatically run tests at exit?
+    # Already tests have run?
     def self.run?
       @run ||= false
     end

data/test-unit/lib/test/unit/assertionfailederror.rb

@@ -9,6 +9,17 @@ module Test
 
     # Thrown by Test::Unit::Assertions when an assertion fails.
     class AssertionFailedError < StandardError
+      attr_accessor :expected, :actual, :user_message
+      attr_accessor :inspected_expected, :inspected_actual
+      def initialize(message=nil, options=nil)
+        options ||= {}
+        @expected = options[:expected]
+        @actual = options[:actual]
+        @inspected_expected = options[:inspected_expected]
+        @inspected_actual = options[:inspected_actual]
+        @user_message = options[:user_message]
+        super(message)
+      end
     end
   end
 end

data/test-unit/lib/test/unit/assertions.rb

@@ -84,7 +84,16 @@ module Test
 <?> expected but was
 <?>.?
 EOT
-        assert_block(full_message) { expected == actual }
+        begin
+          assert_block(full_message) { expected == actual }
+        rescue AssertionFailedError => failure
+          failure.expected = expected
+          failure.actual = actual
+          failure.inspected_expected = AssertionMessage.convert(expected)
+          failure.inspected_actual = AssertionMessage.convert(actual)
+          failure.user_message = message
+          raise
+        end
       end
 
       ##
@@ -789,6 +798,54 @@ EOT
         end
       end
 
+      ##
+      # Passes if +object+#+alias_name+ is an alias method of
+      # +object+#+original_name+.
+      #
+      # Example:
+      #   assert_alias_method([], :length, :size)  # -> pass
+      #   assert_alias_method([], :size, :length)  # -> pass
+      #   assert_alias_method([], :each, :size)    # -> fail
+      def assert_alias_method(object, alias_name, original_name, message=nil)
+        _wrap_assertion do
+          find_method_failure_message = Proc.new do |method_name|
+            build_message(message,
+                          "<?>.? doesn't exist\n" +
+                          "(Class: <?>)",
+                          object,
+                          AssertionMessage.literal(method_name),
+                          object.class)
+          end
+
+          alias_method = original_method = nil
+          assert_block(find_method_failure_message.call(alias_name)) do
+            begin
+              alias_method = object.method(alias_name)
+              true
+            rescue NameError
+              false
+            end
+          end
+          assert_block(find_method_failure_message.call(original_name)) do
+            begin
+              original_method = object.method(original_name)
+              true
+            rescue NameError
+              false
+            end
+          end
+
+          full_message = build_message(message,
+                                       "<?> is alias of\n" +
+                                       "<?> expected",
+                                       alias_method,
+                                       original_method)
+          assert_block(full_message) do
+            alias_method == original_method
+          end
+        end
+      end
+
       ##
       # Builds a failure message.  +head+ is added before the +template+ and
       # +arguments+ replaces the '?'s positionally in the template.
@@ -889,15 +946,24 @@ EOT
             end
           end
 
+          def prepare_for_diff(from, to)
+            if !from.is_a?(String) or !to.is_a?(String)
+              from = convert(from)
+              to = convert(to)
+            end
+
+            if diff_target_string?(from) and diff_target_string?(to)
+              [from, to]
+            else
+              [nil, nil]
+            end
+          end
+
           def delayed_diff(from, to)
             delayed_literal do
-              if !from.is_a?(String) or !to.is_a?(String)
-                from = convert(from)
-                to = convert(to)
-              end
+              from, to = prepare_for_diff(from, to)
 
-              diff = nil
-              diff = "" if !diff_target_string?(from) or !diff_target_string?(to)
+              diff = "" if from.nil? or to.nil?
               diff ||= Diff.readable(from, to)
               if /^[-+]/ !~ diff
                 diff = ""
@@ -930,7 +996,10 @@ EOM
               if use_pp
                 begin
                   require 'pp' unless defined?(PP)
-                  return PP.pp(object, '').chomp
+                  begin
+                    return PP.pp(object, '').chomp
+                  rescue NameError
+                  end
                 rescue LoadError
                   self.use_pp = false
                 end