lib/bindata/sanitize.rb in bindata-2.3.3 vs lib/bindata/sanitize.rb in bindata-2.3.4

@@ -99,19 +99,19 @@
     def each(&block)
       @fields.each(&block)
     end
 
     def field_names
-      @fields.collect { |field| field.name_as_sym }
+      @fields.collect(&:name_as_sym)
     end
 
-    def has_field_name?(name)
+    def field_name?(name)
       @fields.detect { |f| f.name_as_sym == name.to_sym }
     end
 
     def all_field_names_blank?
-      @fields.all? { |f| f.name == nil }
+      @fields.all? { |f| f.name.nil? }
     end
 
     def no_field_names_blank?
       @fields.all? { |f| f.name != nil }
     end
@@ -198,66 +198,66 @@
 
       if hints[:endian]
         self[:endian] ||= hints[:endian]
       end
 
-      if hints[:search_prefix] and not hints[:search_prefix].empty?
+      if hints[:search_prefix] && !hints[:search_prefix].empty?
         self[:search_prefix] = Array(self[:search_prefix]).concat(Array(hints[:search_prefix]))
       end
 
       sanitize!
     end
 
-    alias_method :has_parameter?, :has_key?
+    alias_method :has_parameter?, :key?
 
     def needs_sanitizing?(key)
       parameter = self[key]
 
-      parameter and not parameter.is_a?(SanitizedParameter)
+      parameter && !parameter.is_a?(SanitizedParameter)
     end
 
     def warn_replacement_parameter(bad_key, suggested_key)
       if has_parameter?(bad_key)
-        Kernel.warn ":#{bad_key} is not used with #{@the_class}.  " +
-        "You probably want to change this to :#{suggested_key}"
+        Kernel.warn ":#{bad_key} is not used with #{@the_class}.  " \
+                    "You probably want to change this to :#{suggested_key}"
       end
     end
 
 #    def warn_renamed_parameter(old_key, new_key)
 #      val = delete(old_key)
 #      if val
 #        self[new_key] = val
-#        Kernel.warn ":#{old_key} has been renamed to :#{new_key} in #{@the_class}.  " +
+#        Kernel.warn ":#{old_key} has been renamed to :#{new_key} in #{@the_class}.  " \
 #        "Using :#{old_key} is now deprecated and will be removed in the future"
 #      end
 #    end
 
     def must_be_integer(*keys)
       keys.each do |key|
         if has_parameter?(key)
           parameter = self[key]
-          unless Symbol === parameter or
-                 parameter.respond_to? :arity or
-                 parameter.respond_to? :to_int
-            raise ArgumentError, "parameter '#{key}' in #{@the_class} must " +
+          unless Symbol === parameter ||
+                 parameter.respond_to?(:arity) ||
+                 parameter.respond_to?(:to_int)
+            raise ArgumentError, "parameter '#{key}' in #{@the_class} must " \
                                  "evaluate to an integer, got #{parameter.class}"
           end
         end
       end
     end
 
     def hints
-      { :endian => self[:endian], :search_prefix => self[:search_prefix] }
+      { endian: self[:endian], search_prefix: self[:search_prefix] }
     end
 
     def create_sanitized_endian(endian)
       if endian == :big
         BIG_ENDIAN
       elsif endian == :little
         LITTLE_ENDIAN
       elsif endian == :big_and_little
-        raise ArgumentError, ":endian => :big or :endian => :little is required"
+        raise ArgumentError, "endian: :big or endian: :little is required"
       else
         raise ArgumentError, "unknown value for endian '#{endian}'"
       end
     end
 
@@ -316,15 +316,14 @@
 
     def ensure_mutual_exclusion_of_parameters
       return if length < 2
 
       @the_class.mutually_exclusive_parameters.each do |key1, key2|
-        if has_parameter?(key1) and has_parameter?(key2)
-          raise ArgumentError, "params '#{key1}' and '#{key2}' " +
+        if has_parameter?(key1) && has_parameter?(key2)
+          raise ArgumentError, "params '#{key1}' and '#{key2}' " \
                                "are mutually exclusive in #{@the_class}"
         end
       end
     end
   end
   #----------------------------------------------------------------------------
-
 end