rcap 2.4.1 → 2.7.3

data/lib/rcap/cap_1_2/resource.rb

@@ -1,30 +1,29 @@
+# frozen_string_literal: true
+
 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'
+      DEREF_URI_ELEMENT_NAME = 'derefUri'
 
-      DEREF_URI_XPATH     = "cap:#{ DEREF_URI_ELEMENT_NAME }"
+      DEREF_URI_XPATH = "cap:#{DEREF_URI_ELEMENT_NAME}"
 
       # @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 +38,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,51 +50,52 @@ 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
 
-      DEREF_URI_KEY     = 'deref_uri'
+      DEREF_URI_KEY = 'deref_uri'
 
       # @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,9 @@
+# frozen_string_literal: true
+
 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,21 @@
+# frozen_string_literal: true
+
 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 +23,130 @@ 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 ])
-        unless value && value.valid?
-          object.errors[ attribute ] << options[ :message ]
-        end
+      validates_each(*attributes) do |object, attribute, value|
+        next if  value.nil? && options[:allow_nil]
+        object.errors[attribute] << options[:message] unless value&.valid?
       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?(&: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]
+        next if collection.empty? && options[:allow_empty]
         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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Array
   # Formats an array into a string suitable for a CAP message.
   #
@@ -6,7 +8,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,3 +1,5 @@
+# frozen_string_literal: true
+
 class Date
   alias inspect to_s
 
@@ -6,6 +8,6 @@ class Date
   # @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,3 +1,5 @@
+# frozen_string_literal: true
+
 class DateTime
   alias inspect to_s
 
@@ -6,7 +8,7 @@ class DateTime
   # @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
 
@@ -15,7 +17,8 @@ class DateTime
   end
 
   private
+
   def utc_hours_offset
-    self.offset * 24
+    offset * 24
   end
 end

data/lib/rcap/extensions/float.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Float
   def blank?
     false

data/lib/rcap/extensions/integer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Integer
+  def blank?
+    false
+  end
+end

data/lib/rcap/extensions/nil_class.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class NilClass
   def blank?
     true