fix trailing whitespaces

Author: nolman

lib/net/ber/core_ext.rb

@@ -28,35 +28,35 @@ class String
 
 require 'net/ber/core_ext/array'
 # :stopdoc:
-class Array 
+class Array
   include Net::BER::Extensions::Array
 end
 # :startdoc:
 
 require 'net/ber/core_ext/bignum'
 # :stopdoc:
-class Bignum 
+class Bignum
   include Net::BER::Extensions::Bignum
 end
 # :startdoc:
 
 require 'net/ber/core_ext/fixnum'
 # :stopdoc:
-class Fixnum 
+class Fixnum
   include Net::BER::Extensions::Fixnum
 end
 # :startdoc:
 
 require 'net/ber/core_ext/true_class'
 # :stopdoc:
-class TrueClass 
+class TrueClass
   include Net::BER::Extensions::TrueClass
 end
 # :startdoc:
 
 require 'net/ber/core_ext/false_class'
 # :stopdoc:
-class FalseClass 
+class FalseClass
   include Net::BER::Extensions::FalseClass
 end
 # :startdoc:

lib/net/ldap.rb

@@ -486,7 +486,7 @@ def authenticate(username, password)
   # standard port for simple-TLS encrypted connections is 636. Be sure you
   # are using the correct port.
   #
-  # The :start_tls like the :simple_tls encryption method also encrypts all 
+  # The :start_tls like the :simple_tls encryption method also encrypts all
   # communcations with the LDAP server. With the exception that it operates
   # over the standard TCP port.
   def encryption(args)

lib/net/ldap/entry.rb

@@ -115,7 +115,7 @@ def [](name)
 
   ##
   # Read the first value for the provided attribute. The attribute name
-  # is canonicalized prior to reading. Returns nil if the attribute does 
+  # is canonicalized prior to reading. Returns nil if the attribute does
   # not exist.
   def first(name)
     self[name].first

lib/net/ldap/filter.rb

@@ -242,7 +242,7 @@ def present?(attribute)
 
     # http://tools.ietf.org/html/rfc4515 lists these exceptions from UTF1
     # charset for filters. All of the following must be escaped in any normal
-    # string using a single backslash ('\') as escape. 
+    # string using a single backslash ('\') as escape.
     #
     ESCAPES = {
       "\0" => '00', # NUL            = %x00 ; null character
@@ -251,10 +251,10 @@ def present?(attribute)
       ')'  => '29', # RPARENS        = %x29 ; right parenthesis (")")
       '\\' => '5C', # ESC            = %x5C ; esc (or backslash) ("\")
     }
-    # Compiled character class regexp using the keys from the above hash. 
+    # Compiled character class regexp using the keys from the above hash.
     ESCAPE_RE = Regexp.new(
-      "[" + 
-      ESCAPES.keys.map { |e| Regexp.escape(e) }.join + 
+      "[" +
+      ESCAPES.keys.map { |e| Regexp.escape(e) }.join +
       "]")
 
     ##
@@ -310,8 +310,8 @@ def parse_ber(ber)
         present?(ber.to_s)
       when 0xa9 # context-specific constructed 9, "extensible comparison"
         raise Net::LDAP::LdapError, "Invalid extensible search filter, should be at least two elements" if ber.size<2
-        
-        # Reassembles the extensible filter parts 
+
+        # Reassembles the extensible filter parts
         # (["sn", "2.4.6.8.10", "Barbara Jones", '1'])
         type = value = dn = rule = nil
         ber.each do |element|
@@ -327,7 +327,7 @@ def parse_ber(ber)
         attribute << type if type
         attribute << ":#{dn}" if dn
         attribute << ":#{rule}" if rule
-        
+
         ex(attribute, value)
       else
         raise Net::LDAP::LdapError, "Invalid BER tag-value (#{ber.ber_identifier}) in search filter."

spec/integration/ssl_ber_spec.rb

@@ -4,7 +4,7 @@
 require 'timeout'
 
 describe "BER serialisation (SSL)" do
-  # Transmits str to #to and reads it back from #from. 
+  # Transmits str to #to and reads it back from #from.
   #
   def transmit(str)
     Timeout::timeout(1) do
@@ -14,26 +14,26 @@ def transmit(str)
       from.read
     end
   end
-    
+
   attr_reader :to, :from
   before(:each) do
     @from, @to = IO.pipe
-    
+
     # The production code operates on sockets, which do need #connect called
-    # on them to work. Pipes are more robust for this test, so we'll skip 
-    # the #connect call since it fails. 
+    # on them to work. Pipes are more robust for this test, so we'll skip
+    # the #connect call since it fails.
     flexmock(OpenSSL::SSL::SSLSocket).
       new_instances.should_receive(:connect => nil)
-              
+
     @to   = Net::LDAP::Connection.wrap_with_ssl(to)
     @from = Net::LDAP::Connection.wrap_with_ssl(from)
   end
-  
+
   it "should transmit strings" do
     transmit('foo').should == 'foo'
-  end 
+  end
   it "should correctly transmit numbers" do
     to.write 1234.to_ber
     from.read_ber.should == 1234
-  end 
+  end
 end

spec/unit/ber/ber_spec.rb

@@ -5,7 +5,7 @@
 
 describe "BER encoding of" do
 
-  RSpec::Matchers.define :properly_encode_and_decode do 
+  RSpec::Matchers.define :properly_encode_and_decode do
     match do |given|
       given.to_ber.read_ber.should == given
     end
@@ -64,13 +64,13 @@
           n = 2 << p
           n.should properly_encode_and_decode
         end
-      end 
+      end
       it "should correctly handle powers of ten" do
         100.times do |p|
           n = 5 * 10**p
           n.should properly_encode_and_decode
         end
-      end 
+      end
     end
   end
   if "Ruby 1.9".respond_to?(:encoding)
@@ -106,7 +106,7 @@
       "0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus".
         read_ber(Net::LDAP::AsnSyntax).should ==
           [1, [3, "Administrator", "ad_is_bogus"]]
-    end 
+    end
   end
 end
 

spec/unit/ber/core_ext/string_spec.rb

@@ -9,10 +9,10 @@
         @str = raw_string("0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus UNCONSUMED")
         @result = str.read_ber!(Net::LDAP::AsnSyntax)
       end
-      
+
       it "should correctly parse the ber message" do
         result.should == [1, [3, "Administrator", "ad_is_bogus"]]
-      end 
+      end
       it "should leave unconsumed part of message in place" do
         str.should == " UNCONSUMED"
       end
@@ -21,9 +21,9 @@
         attr_reader :initial_value
         before(:each) do
           stub_exception_class = Class.new(StandardError)
-          
+
           @initial_value = raw_string("0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus")
-          @str = initial_value.dup 
+          @str = initial_value.dup
 
           # Defines a string
           io = StringIO.new(initial_value)
@@ -32,16 +32,16 @@
             raise stub_exception_class
           end
           flexmock(StringIO).should_receive(:new).and_return(io)
-          
+
           begin
-            str.read_ber!(Net::LDAP::AsnSyntax)            
+            str.read_ber!(Net::LDAP::AsnSyntax)
           rescue stub_exception_class
             # EMPTY ON PURPOSE
           else
             raise "The stub code should raise an exception!"
           end
         end
-        
+
         it "should not modify string" do
           str.should == initial_value
         end

spec/unit/ldap/dn_spec.rb

@@ -11,7 +11,7 @@
 
     it "should construct a Net::LDAP::DN" do
       dn.should be_an_instance_of(Net::LDAP::DN)
-    end 
+    end
 
     it "should escape all the required characters" do
       dn.to_s.should == 'cn=\\,\\+\\"\\\\\\<\\>\\;,ou=company'
@@ -75,6 +75,6 @@
   describe "<- .escape(str)" do
     it "should escape ,, +, \", \\, <, >, and ;" do
       Net::LDAP::DN.escape(',+"\\<>;').should == '\\,\\+\\"\\\\\\<\\>\\;'
-    end 
+    end
   end
 end

spec/unit/ldap/entry_spec.rb

@@ -14,38 +14,38 @@
   describe "entry access" do
     it "should always respond to #dn" do
       entry.should respond_to(:dn)
-    end 
-    
+    end
+
     context "<- #foo" do
       it "should respond_to?" do
         entry.should respond_to(:foo)
-      end 
+      end
       it "should return 'foo'" do
         entry.foo.should == ['foo']
       end
     end
     context "<- #Foo" do
       it "should respond_to?" do
         entry.should respond_to(:Foo)
-      end 
+      end
       it "should return 'foo'" do
         entry.foo.should == ['foo']
-      end 
+      end
     end
     context "<- #foo=" do
       it "should respond_to?" do
         entry.should respond_to(:foo=)
-      end 
+      end
       it "should set 'foo'" do
         entry.foo= 'bar'
         entry.foo.should == ['bar']
-      end 
+      end
     end
     context "<- #fOo=" do
       it "should return 'foo'" do
         entry.fOo= 'bar'
         entry.fOo.should == ['bar']
-      end 
+      end
     end
   end
 end

spec/unit/ldap/filter_spec.rb

@@ -9,21 +9,21 @@
       end
       it "should convert to 'foo:=bar'" do
         filter.to_s.should == '(foo:=bar)'
-      end 
+      end
       it "should survive roundtrip via to_s/from_rfc2254" do
         Net::LDAP::Filter.from_rfc2254(filter.to_s).should == filter
-      end 
+      end
       it "should survive roundtrip conversion to/from ber" do
         ber = filter.to_ber
         Net::LDAP::Filter.parse_ber(ber.read_ber(Net::LDAP::AsnSyntax)).should ==
           filter
-      end 
+      end
     end
     context "various legal inputs" do
       [
-        '(o:dn:=Ace Industry)', 
-        '(:dn:2.4.8.10:=Dino)', 
-        '(cn:dn:1.2.3.4.5:=John Smith)', 
+        '(o:dn:=Ace Industry)',
+        '(:dn:2.4.8.10:=Dino)',
+        '(cn:dn:1.2.3.4.5:=John Smith)',
         '(sn:dn:2.4.6.8.10:=Barbara Jones)',
         '(&(sn:dn:2.4.6.8.10:=Barbara Jones))'
       ].each do |filter_str|
@@ -35,20 +35,20 @@
 
           it "should decode into a Net::LDAP::Filter" do
             filter.should be_an_instance_of(Net::LDAP::Filter)
-          end 
+          end
           it "should survive roundtrip conversion to/from ber" do
             ber = filter.to_ber
             Net::LDAP::Filter.parse_ber(ber.read_ber(Net::LDAP::AsnSyntax)).should ==
               filter
-          end 
+          end
         end
       end
     end
   end
   describe "<- .construct" do
     it "should accept apostrophes in filters (regression)" do
       Net::LDAP::Filter.construct("uid=O'Keefe").to_rfc2254.should == "(uid=O'Keefe)"
-    end 
+    end
   end
 
   describe "convenience filter constructors" do
@@ -58,28 +58,28 @@ def eq(attribute, value)
     describe "<- .equals(attr, val)" do
       it "should delegate to .eq with escaping" do
         described_class.equals('dn', 'f*oo').should == eq('dn', 'f\2Aoo')
-      end 
+      end
     end
     describe "<- .begins(attr, val)" do
       it "should delegate to .eq with escaping" do
         described_class.begins('dn', 'f*oo').should == eq('dn', 'f\2Aoo*')
-      end 
+      end
     end
     describe "<- .ends(attr, val)" do
       it "should delegate to .eq with escaping" do
         described_class.ends('dn', 'f*oo').should == eq('dn', '*f\2Aoo')
-      end 
+      end
     end
     describe "<- .contains(attr, val)" do
       it "should delegate to .eq with escaping" do
         described_class.contains('dn', 'f*oo').should == eq('dn', '*f\2Aoo*')
-      end 
+      end
     end
   end
   describe "<- .escape(str)" do
     it "should escape nul, *, (, ) and \\" do
       Net::LDAP::Filter.escape("\0*()\\").should == "\\00\\2A\\28\\29\\5C"
-    end 
+    end
   end
 
   context 'with a well-known BER string' do