rcap 2.4.1 → 2.5.0

data/lib/rcap/cap_1_2/parameter.rb

@@ -1,11 +1,9 @@
 module RCAP
   module CAP_1_2
-
     # A Parameter object is valid if
     # * it has a name
     # * it has a value
     class Parameter < RCAP::Base::Parameter
-
       # @return [String]
       def xmlns
         Alert::XMLNS

data/lib/rcap/cap_1_2/point.rb

@@ -1,6 +1,5 @@
 module RCAP
   module CAP_1_2
-
     # A Point object is valid if
     # * it has a lattitude within the minimum and maximum lattitude values
     # * it has a longitude within the minimum and maximum longitude values

data/lib/rcap/cap_1_2/polygon.rb

@@ -1,12 +1,10 @@
 module RCAP
   module CAP_1_2
-
     # A Polygon object is valid if
     # * it has a minimum of three points
     # * each Point object in the points collection is valid
     class Polygon < RCAP::Base::Polygon
-
-      validates_length_of( :points, :minimum => 4 )
+      validates_length_of(:points, minimum: 4)
 
       # @return [Class]
       def point_class

data/lib/rcap/cap_1_2/resource.rb

@@ -1,15 +1,13 @@
 module RCAP
   module CAP_1_2
-
     # A Resource object is valid if
     # * it has a resource description
     # * it has a mime_type
     class Resource < RCAP::Base::Resource
-
       # @return [String] Dereferenced URI - contents of URI Base64 encoded
-      attr_accessor( :deref_uri )
+      attr_accessor(:deref_uri)
 
-      validates_presence_of( :mime_type )
+      validates_presence_of(:mime_type)
 
       DEREF_URI_ELEMENT_NAME     = 'derefUri'
 
@@ -18,13 +16,13 @@ module RCAP
       # @return [REXML::Element]
       def to_xml_element
         xml_element = super
-        xml_element = REXML::Element.new( XML_ELEMENT_NAME )
-        xml_element.add_element( RESOURCE_DESC_ELEMENT_NAME ).add_text( @resource_desc )
-        xml_element.add_element( MIME_TYPE_ELEMENT_NAME ).add_text( @mime_type ) if @mime_type
-        xml_element.add_element( SIZE_ELEMENT_NAME ).add_text( @size.to_s )      if @size
-        xml_element.add_element( URI_ELEMENT_NAME ).add_text( @uri )             if @uri
-        xml_element.add_element( DEREF_URI_ELEMENT_NAME ).add_text( @deref_uri ) if @deref_uri
-        xml_element.add_element( DIGEST_ELEMENT_NAME ).add_text( @digest )       if @digest
+        xml_element = REXML::Element.new(XML_ELEMENT_NAME)
+        xml_element.add_element(RESOURCE_DESC_ELEMENT_NAME).add_text(@resource_desc)
+        xml_element.add_element(MIME_TYPE_ELEMENT_NAME).add_text(@mime_type) if @mime_type
+        xml_element.add_element(SIZE_ELEMENT_NAME).add_text(@size.to_s)      if @size
+        xml_element.add_element(URI_ELEMENT_NAME).add_text(@uri)             if @uri
+        xml_element.add_element(DEREF_URI_ELEMENT_NAME).add_text(@deref_uri) if @deref_uri
+        xml_element.add_element(DIGEST_ELEMENT_NAME).add_text(@digest)       if @digest
         xml_element
       end
 
@@ -39,9 +37,9 @@ module RCAP
       #
       # @return [Array(Integer,String)]
       def dereference_uri!
-        content = URI.parse( self.uri ).read
-        @deref_uri = Base64.encode64( content )
-        self.calculate_hash_and_size
+        content = URI.parse(uri).read
+        @deref_uri = Base64.encode64(content)
+        calculate_hash_and_size
       end
 
       # @return [String]
@@ -51,31 +49,31 @@ module RCAP
 
       # @param [REXML::Element] resource_xml_element
       # @return [Resource]
-      def self.from_xml_element( resource_xml_element )
+      def self.from_xml_element(resource_xml_element)
         super.tap do |resource|
-          resource.deref_uri = RCAP.xpath_text( resource_xml_element, DEREF_URI_XPATH, resource.xmlns )
+          resource.deref_uri = RCAP.xpath_text(resource_xml_element, DEREF_URI_XPATH, resource.xmlns)
         end
       end
 
-      DEREF_URI_YAML     = "Derefrenced URI Data"
+      DEREF_URI_YAML     = 'Derefrenced URI Data'
 
       # @param [Hash] options
       # @return [String]
-      def to_yaml( options = {} )
+      def to_yaml(options = {})
         RCAP.attribute_values_to_hash(
-          [ RESOURCE_DESC_YAML, @resource_desc ],
-          [ URI_YAML,           @uri ],
-          [ MIME_TYPE_YAML,     @mime_type ],
-          [ DEREF_URI_YAML,     @deref_uri ],
-          [ SIZE_YAML,          @size ],
-          [ DIGEST_YAML,        @digest ]).to_yaml( options )
+          [RESOURCE_DESC_YAML, @resource_desc],
+          [URI_YAML,           @uri],
+          [MIME_TYPE_YAML,     @mime_type],
+          [DEREF_URI_YAML,     @deref_uri],
+          [SIZE_YAML,          @size],
+          [DIGEST_YAML,        @digest]).to_yaml(options)
       end
 
       # @param [Hash] resource_yaml_data
       # @return [Resource]
-      def self.from_yaml_data( resource_yaml_data )
+      def self.from_yaml_data(resource_yaml_data)
         super.tap do |resource|
-          resource.deref_uri = resource_yaml_data[ DEREF_URI_YAML ].strip if resource_yaml_data[ DEREF_URI_YAML ]
+          resource.deref_uri = resource_yaml_data[DEREF_URI_YAML].strip if resource_yaml_data[DEREF_URI_YAML]
         end
       end
 
@@ -83,19 +81,19 @@ module RCAP
 
       # @return [Hash]
       def to_h
-        RCAP.attribute_values_to_hash( [ RESOURCE_DESC_KEY, @resource_desc ],
-                                       [ URI_KEY,           @uri],
-                                       [ MIME_TYPE_KEY,     @mime_type],
-                                       [ DEREF_URI_KEY,     @deref_uri],
-                                       [ SIZE_KEY,          @size ],
-                                       [ DIGEST_KEY,        @digest ])
+        RCAP.attribute_values_to_hash([RESOURCE_DESC_KEY, @resource_desc],
+                                      [URI_KEY,           @uri],
+                                      [MIME_TYPE_KEY,     @mime_type],
+                                      [DEREF_URI_KEY,     @deref_uri],
+                                      [SIZE_KEY,          @size],
+                                      [DIGEST_KEY,        @digest])
       end
 
       # @param [Hash] resource_hash
       # @return [Resource]
-      def self.from_h( resource_hash )
+      def self.from_h(resource_hash)
         super.tap do |resource|
-          resource.deref_uri = resource_hash[ DEREF_URI_KEY ].strip if resource_hash[ DEREF_URI_KEY ]
+          resource.deref_uri = resource_hash[DEREF_URI_KEY].strip if resource_hash[DEREF_URI_KEY]
         end
       end
     end

data/lib/rcap/config.rb

@@ -1,7 +1,7 @@
 module RCAP
-  XML_PRETTY_PRINTER = REXML::Formatters::Pretty.new( 2 )
+  XML_PRETTY_PRINTER = REXML::Formatters::Pretty.new(2)
   XML_PRETTY_PRINTER.compact = true
 
-  RCAP_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S"
-  RCAP_ZONE_FORMAT = "%+03i:00"
+  RCAP_TIME_FORMAT = '%Y-%m-%dT%H:%M:%S'
+  RCAP_ZONE_FORMAT = '%+03i:00'
 end

data/lib/rcap/custom_validators.rb

@@ -1,20 +1,19 @@
 module Validation
   module ClassMethods
-
-    CAP_NUMBER_REGEX  = Regexp.new( '^-{0,1}\d*\.{0,1}\d+$' )
-    CAP_INTEGER_REGEX = Regexp.new( '\-{0,1}A[+-]?\d+\Z' )
+    CAP_NUMBER_REGEX  = Regexp.new('^-{0,1}\d*\.{0,1}\d+$')
+    CAP_INTEGER_REGEX = Regexp.new('\-{0,1}A[+-]?\d+\Z')
 
     # @example
     #   validates_inclusion_of( :status, :in => VALID_STATUSES )
-    def validates_inclusion_of( *attributes )
+    def validates_inclusion_of(*attributes)
       options = {
-        :message => 'is not in the required range'
-      }.merge!( attributes.extract_options! )
+        message: 'is not in the required range'
+      }.merge!(attributes.extract_options!)
 
-      validates_each( *attributes ) do |object, attribute, value|
-        next if ( value.nil? && options[ :allow_nil ])
-        unless options[ :in ].include?( value )
-          object.errors[ attribute ] << options[ :message ]
+      validates_each(*attributes) do |object, attribute, value|
+        next if  value.nil? && options[:allow_nil]
+        unless options[:in].include?(value)
+          object.errors[attribute] << options[:message]
         end
       end
     end
@@ -22,134 +21,131 @@ module Validation
     # Will validate all members of a collection are found in a given collection.
     # @example
     #   validates_inclusion_of_members_of( :categories, :in => VALID_CATEGORIES )
-    def validates_inclusion_of_members_of( *attributes )
+    def validates_inclusion_of_members_of(*attributes)
       options = {
-        :message => 'contains members that are not valid'
-      }.merge!( attributes.extract_options! )
+        message: 'contains members that are not valid'
+      }.merge!(attributes.extract_options!)
 
-      validates_each( *attributes ) do |object, attribute, collection|
-        next if ( collection.nil? && options[ :allow_nil ]) || ( collection.empty? && options[ :allow_empty ])
-        unless collection.all?{ |member| options[ :in ].include?( member )}
-          object.errors[ attribute ] << options[ :message ]
+      validates_each(*attributes) do |object, attribute, collection|
+        next if ( collection.nil? && options[:allow_nil]) || ( collection.empty? && options[:allow_empty])
+        unless collection.all? { |member| options[:in].include?(member) }
+          object.errors[attribute] << options[:message]
         end
       end
     end
 
-    def validates_length_of_members_of( *attributes )
+    def validates_length_of_members_of(*attributes)
       options = {
-        :message => 'contains members with incorrect length'
-      }.merge!( attributes.extract_options! )
+        message: 'contains members with incorrect length'
+      }.merge!(attributes.extract_options!)
 
-      validates_each( *attributes ) do |object, attribute, collection|
-        next if ( collection.nil? && options[ :allow_nil ]) || ( collection.empty? && options[ :allow_empty ])
-        unless options[ :minimum ] && collection.length >= options[ :minimum ]
-          object.errors[ attribute ] << options[ :message ]
+      validates_each(*attributes) do |object, attribute, collection|
+        next if ( collection.nil? && options[:allow_nil]) || ( collection.empty? && options[:allow_empty])
+        unless options[:minimum] && collection.length >= options[:minimum]
+          object.errors[attribute] << options[:message]
         end
       end
     end
 
-    def validates_validity_of( *attributes )
+    def validates_validity_of(*attributes)
       options = {
-        :message => 'is not valid'
-      }.merge!( attributes.extract_options! )
+        message: 'is not valid'
+      }.merge!(attributes.extract_options!)
 
-      validates_each( *attributes ) do |object, attribute, value|
-        next if ( value.nil? && options[ :allow_nil ])
+      validates_each(*attributes) do |object, attribute, value|
+        next if  value.nil? && options[:allow_nil]
         unless value && value.valid?
-          object.errors[ attribute ] << options[ :message ]
+          object.errors[attribute] << options[:message]
         end
       end
     end
 
-    def validates_collection_of( *attributes )
+    def validates_collection_of(*attributes)
       options = {
-        :message => 'contains an invalid element'
-      }.merge!( attributes.extract_options! )
+        message: 'contains an invalid element'
+      }.merge!(attributes.extract_options!)
 
-      validates_each( *attributes ) do |object, attribute, collection|
-        next if ( collection.nil? && options[ :allow_nil ]) || ( collection.empty? && options[ :allow_empty ])
-        unless collection.all?{ |element| element.valid? }
-          object.errors[ attribute ] << options[ :message ]
+      validates_each(*attributes) do |object, attribute, collection|
+        next if ( collection.nil? && options[:allow_nil]) || ( collection.empty? && options[:allow_empty])
+        unless collection.all? { |element| element.valid? }
+          object.errors[attribute] << options[:message]
         end
       end
     end
 
-    def validates_dependency_of( *attributes )
+    def validates_dependency_of(*attributes)
       options = {
-        :message => 'is dependent on :attribute being defined'
-      }.merge!( attributes.extract_options! )
+        message: 'is dependent on :attribute being defined'
+      }.merge!(attributes.extract_options!)
 
-      validates_each( *attributes ) do |object, attribute, value|
+      validates_each(*attributes) do |object, attribute, value|
         next if value.blank?
-        contingent_on_attribute = object.send( options[ :on ])
-        contingent_on_attribute_value = options[ :with_value ]
+        contingent_on_attribute = object.send(options[:on])
+        contingent_on_attribute_value = options[:with_value]
 
         if contingent_on_attribute.nil? || !contingent_on_attribute_value.nil? && contingent_on_attribute_value != contingent_on_attribute
-          object.errors[ attribute ] << options[ :message ].gsub( /:attribute/, options[ :on ].to_s )
+          object.errors[attribute] << options[:message].gsub(/:attribute/, options[:on].to_s)
         end
       end
     end
 
-    def validates_conditional_presence_of( *attributes )
+    def validates_conditional_presence_of(*attributes)
       options = {
-        :message => 'is not defined but is required by :contingent_attribute'
-      }.merge!( attributes.extract_options! )
+        message: 'is not defined but is required by :contingent_attribute'
+      }.merge!(attributes.extract_options!)
 
-      validates_each( *attributes ) do |object, attribute, value|
-        contingent_attribute_value = object.send( options[ :when ] )
-        required_contingent_attribute_value = options[ :is ]
+      validates_each(*attributes) do |object, attribute, value|
+        contingent_attribute_value = object.send(options[:when])
+        required_contingent_attribute_value = options[:is]
 
-        next if contingent_attribute_value.nil? || contingent_attribute_value != required_contingent_attribute_value && !options[ :is ].blank?
+        next if contingent_attribute_value.nil? || contingent_attribute_value != required_contingent_attribute_value && !options[:is].blank?
         if value.blank?
-          object.errors[ attribute ] << options[ :message ].gsub( /:contingent_attribute/, options[ :whenn ].to_s )
+          object.errors[attribute] << options[:message].gsub(/:contingent_attribute/, options[:whenn].to_s)
         end
       end
     end
 
-
-    def validates_numericality_of( *attributes )
+    def validates_numericality_of(*attributes)
       options = {
-        :message => 'is not a number or does not meet a conditional requirement',
+        message: 'is not a number or does not meet a conditional requirement',
       }.merge!(attributes.extract_options!)
 
       re = options[:only_integer] ? CAP_INTEGER_REGEX : CAP_NUMBER_REGEX
 
-      validates_each( *attributes ) do |object, attribute, value|
-        next if (value.nil? && options[ :allow_nil ])
-        unless ( value.to_s =~ re ) &&
-          ( options[ :greater_than ].nil? || value && value > options[ :greater_than ]) &&
-          ( options[ :greater_than_or_equal ].nil? || value && value >= options[ :greater_than_or_equal])
-          object.errors[ attribute ] << options[ :message ]
+      validates_each(*attributes) do |object, attribute, value|
+        next if value.nil? && options[:allow_nil]
+        unless ( value.to_s =~ re) &&
+          ( options[:greater_than].nil? || value && value > options[:greater_than]) &&
+          ( options[:greater_than_or_equal].nil? || value && value >= options[:greater_than_or_equal])
+          object.errors[attribute] << options[:message]
         end
       end
     end
 
-
-    def validates_responsiveness_of( *attributes )
+    def validates_responsiveness_of(*attributes)
       options = {
-        :message => 'does not respond to the given method'
-      }.merge!( attributes.extract_options! )
+        message: 'does not respond to the given method'
+      }.merge!(attributes.extract_options!)
 
-      validates_each( *attributes ) do |object, attribute, value|
-        next if ( collection.nil? && options[ :allow_nil ])
-        unless options[ :to ].all?{ |method_name| object.respond_to?( method_name )}
-          object.errors[ attribute ] << options [ :message ]
+      validates_each(*attributes) do |object, attribute, _value|
+        next if  collection.nil? && options[:allow_nil]
+        unless options[:to].all? { |method_name| object.respond_to?(method_name) }
+          object.errors[attribute] << options [:message]
         end
       end
     end
 
-    def validates_equality_of_first_and_last( *attributes )
+    def validates_equality_of_first_and_last(*attributes)
       options = {
-        :message => 'does not have equal first and last elements'
-      }.merge!( attributes.extract_options! )
+        message: 'does not have equal first and last elements'
+      }.merge!(attributes.extract_options!)
 
-      validates_each( *attributes ) do |object, attribute, collection|
-        next if ( collection.nil? && options[ :allow_nil ])
+      validates_each(*attributes) do |object, attribute, collection|
+        next if  collection.nil? && options[:allow_nil]
         unless collection.first == collection.last
-          object.errors[ attribute ] << options[ :message ]
+          object.errors[attribute] << options[:message]
         end
       end
     end
   end
 end
-

data/lib/rcap/extensions/array.rb

@@ -6,7 +6,7 @@ class Array
   #   [ "one", "two words", "three" ].to_s_for_cap # => "one \"two words\" three"
   # @see String#unpack_cap_list
   def to_s_for_cap
-    self.map{ |element| element.to_s.for_cap_list }.join( ' ' )
+    map { |element| element.to_s.for_cap_list }.join(' ')
   end
 
   def blank?

data/lib/rcap/extensions/date.rb

@@ -1,11 +1,11 @@
 class Date
-  alias inspect to_s
+  alias_method :inspect, :to_s
 
   # Returns a string representaion of the time suitable for CAP.
   # @return [String]
   # @example
   #   Date.today.to_s_for_cap # => "2011-10-26T00:00:00+00:00"
   def to_s_for_cap
-    self.to_datetime.to_s_for_cap
+    to_datetime.to_s_for_cap
   end
 end

data/lib/rcap/extensions/date_time.rb

@@ -1,12 +1,12 @@
 class DateTime
-  alias inspect to_s
+  alias_method :inspect, :to_s
 
   # Returns a string representaion of the time suitable for CAP.
   # @return [String]
   # @example
   #   DateTime.now.to_s_for_cap # => "2011-10-26T21:45:00+02:00"
   def to_s_for_cap
-    t = self.strftime( RCAP::RCAP_TIME_FORMAT ) + format( RCAP::RCAP_ZONE_FORMAT , utc_hours_offset )
+    t = strftime(RCAP::RCAP_TIME_FORMAT) + format(RCAP::RCAP_ZONE_FORMAT, utc_hours_offset)
     t.sub(/\+(00:\d\d)$/, '-\1')
   end
 
@@ -16,6 +16,6 @@ class DateTime
 
   private
   def utc_hours_offset
-    self.offset * 24
+    offset * 24
   end
 end

data/lib/rcap/extensions/string.rb

@@ -1,5 +1,5 @@
 class String
-  CAP_LIST_REGEX = Regexp.new( '"([\w\s]+)"|(\S+)' )
+  CAP_LIST_REGEX = Regexp.new('"([\w\s]+)"|(\S+)')
   WHITESPACE_REGEX = Regexp.new('^\s+$')
 
   # Reformats string for a CAP list. If the string contains whitespace it will
@@ -11,7 +11,7 @@ class String
   #   "two words".for_cap_list # => "\"two words\""
   def for_cap_list
     if self =~ /\s/
-      '"'+self+'"'
+      '"' + self + '"'
     else
       self
     end
@@ -24,7 +24,7 @@ class String
   #   "one \"two words\" three".unpack_cap_list # => [ "one", "two words", "three" ]
   # @see Array#to_s_for_cap
   def unpack_cap_list
-    self.split( CAP_LIST_REGEX ).reject{ |match| match == "" || match =~ WHITESPACE_REGEX }
+    split(CAP_LIST_REGEX).reject { |match| match == '' || match =~ WHITESPACE_REGEX }
   end
 
   def blank?