fix multiline blocks

lib/net/ldap.rb

@@ -775,10 +775,10 @@ def search(args = {})
 
     instrument "search.net_ldap", args do |payload|
       @result = use_connection(args) do |conn|
-        conn.search(args) { |entry|
+        conn.search(args) do |entry|
           result_set << entry if result_set
           yield entry if block_given?
-        }
+        end
       end
 
       if return_result_set
@@ -917,15 +917,15 @@ def bind(auth = @auth)
   #  end
   def bind_as(args = {})
     result = false
-    open { |me|
+    open do |me|
       rs = search args
       if rs and rs.first and dn = rs.first.dn
         password = args[:password]
         password = password.call if password.respond_to?(:call)
         result = rs if bind(:method => :simple, :username => dn,
                             :password => password)
       end
-    }
+    end
     result
   end
 

lib/net/ldap/auth_adapter/gss_spnego.rb

@@ -22,12 +22,10 @@ def bind(auth)
           user, psw = [auth[:username] || auth[:dn], auth[:password]]
           raise Net::LDAP::BindingInformationInvalidError, "Invalid binding information" unless (user && psw)
 
-          nego = proc { |challenge|
             t2_msg = NTLM::Message.parse(challenge)
             t3_msg = t2_msg.response({ :user => user, :password => psw },
                                      { :ntlmv2 => true })
             t3_msg.serialize
-          }
 
           Net::LDAP::AuthAdapter::Sasl.new(@connection).bind \
             :method             => :sasl,

lib/net/ldap/auth_adapter/sasl.rb

@@ -33,7 +33,7 @@ def bind(auth)
           message_id = @connection.next_msgid
 
           n = 0
-          loop {
+          loop do
             sasl = [mech.to_ber, cred.to_ber].to_ber_contextspecific(3)
             request = [
               Net::LDAP::Connection::LdapVersion.to_ber, "".to_ber, sasl
@@ -50,7 +50,7 @@ def bind(auth)
             raise Net::LDAP::SASLChallengeOverflowError, "sasl-challenge overflow" if ((n += 1) > MaxSaslChallenges)
 
             cred = chall.call(pdu.result_server_sasl_creds)
-          }
+          end
 
           raise Net::LDAP::SASLChallengeOverflowError, "why are we here?"
         end

lib/net/ldap/connection.rb

@@ -500,14 +500,14 @@ def search(args = nil)
   def self.modify_ops(operations)
     ops = []
     if operations
-      operations.each { |op, attrib, values|
+      operations.each do |op, attrib, values|
         # TODO, fix the following line, which gives a bogus error if the
         # opcode is invalid.
         op_ber = MODIFY_OPERATIONS[op.to_sym].to_ber_enumerated
         values = [ values ].flatten.map { |v| v.to_ber if v }.to_ber_set
         values = [ attrib.to_s.to_ber, values ].to_ber_sequence
         ops << [ op_ber, values ].to_ber
-      }
+      end
     end
     ops
   end
@@ -594,9 +594,9 @@ def password_modify(args)
   def add(args)
     add_dn = args[:dn] or raise Net::LDAP::EmptyDNError, "Unable to add empty DN"
     add_attrs = []
-    a = args[:attributes] and a.each { |k, v|
+    a = args[:attributes] and a.each do |k, v|
       add_attrs << [ k.to_s.to_ber, Array(v).map { |m| m.to_ber}.to_ber_set ].to_ber_sequence
-    }
+    end
 
     message_id = next_msgid
     request    = [add_dn.to_ber, add_attrs.to_ber_sequence].to_ber_appsequence(Net::LDAP::PDU::AddRequest)

lib/net/ldap/entry.rb

@@ -141,10 +141,10 @@ def attribute_names
   # (possibly empty) \Array of data values.
   def each # :yields: attribute-name, data-values-array
     if block_given?
-      attribute_names.each {|a|
+      attribute_names.each do|a|
         attr_name,values = a,self[a]
         yield attr_name, values
-      }
+      end
     end
   end
   alias_method :each_attribute, :each

lib/net/ldap/filter.rb

@@ -287,7 +287,7 @@ def parse_ber(ber)
       when 0xa4 # context-specific constructed 4, "substring"
         str = ""
         final = false
-        ber.last.each { |b|
+        ber.last.each do |b|
           case b.ber_identifier
           when 0x80 # context-specific primitive 0, SubstringFilter "initial"
             raise Net::LDAP::SubstringFilterError, "Unrecognized substring filter; bad initial value." if str.length > 0
@@ -298,7 +298,7 @@ def parse_ber(ber)
             str += "*#{escape(b)}"
             final = true
           end
-        }
+        end
         str += "*" unless final
         eq(ber.first.to_s, str)
       when 0xa5 # context-specific constructed 5, "greaterOrEqual"

lib/net/snmp.rb

@@ -227,9 +227,9 @@ def pdu_to_ber_string
           error_status.to_ber,
           error_index.to_ber,
           [
-            @variables.map {|n,v|
+            @variables.map do|n,v|
               [n.to_ber_oid, Net::BER::BerIdentifiedNull.new.to_ber].to_ber_sequence
-            }
+            end
           ].to_ber_sequence
         ].to_ber_contextspecific(0)
       when :get_next_request
@@ -238,9 +238,9 @@ def pdu_to_ber_string
           error_status.to_ber,
           error_index.to_ber,
           [
-            @variables.map {|n,v|
+            @variables.map do|n,v|
               [n.to_ber_oid, Net::BER::BerIdentifiedNull.new.to_ber].to_ber_sequence
-            }
+            end
           ].to_ber_sequence
         ].to_ber_contextspecific(1)
       when :get_response
@@ -249,9 +249,9 @@ def pdu_to_ber_string
           error_status.to_ber,
           error_index.to_ber,
           [
-            @variables.map {|n,v|
+            @variables.map do|n,v|
               [n.to_ber_oid, v.to_ber].to_ber_sequence
-            }
+            end
           ].to_ber_sequence
         ].to_ber_contextspecific(2)
       else

test/test_filter.rb

@@ -13,11 +13,11 @@ def test_invalid_filter_string
   end
 
   def test_invalid_filter
-    assert_raises(Net::LDAP::OperatorError) {
+    assert_raises(Net::LDAP::OperatorError) do
       # This test exists to prove that our constructor blocks unknown filter
       # types. All filters must be constructed using helpers.
       Filter.__send__(:new, :xx, nil, nil)
-    }
+    end
   end
 
   def test_to_s

test/test_snmp.rb

@@ -16,9 +16,9 @@ def self.raw_string(s)
 
   def test_invalid_packet
     data = "xxxx"
-    assert_raise(Net::BER::BerError) {
+    assert_raise(Net::BER::BerError) do
 ary = data.read_ber(Net::SNMP::AsnSyntax)
-    }
+    end
   end
 
   # The method String#read_ber! added by Net::BER consumes a well-formed BER
@@ -40,9 +40,9 @@ def _test_consume_string
   end
 
   def test_weird_packet
-    assert_raise(Net::SnmpPdu::Error) {
+    assert_raise(Net::SnmpPdu::Error) do
 Net::SnmpPdu.parse("aaaaaaaaaaaaaa")
-    }
+    end
   end
 
   def test_get_request